@atlaskit/editor-core 182.0.3 → 182.1.1

package/dist/es2019/editor.js

@@ -15,6 +15,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';
@@ -46,6 +47,9 @@ export default class Editor extends React.Component {
       return (_this$props$onSave = (_this$props = this.props).onSave) === null || _this$props$onSave === void 0 ? void 0 : _this$props$onSave.call(_this$props, view);
     });
     _defineProperty(this, "handleAnalyticsEvent", data => fireAnalyticsEvent(this.createAnalyticsEvent)(data));
+    _defineProperty(this, "getFeatureFlags", () => {
+      return createFeatureFlagsFromProps(this.props);
+    });
     _defineProperty(this, "getExperienceStore", () => this.experienceStore);
     this.providerFactory = new ProviderFactory();
     deprecationWarnings(props);
@@ -213,9 +217,8 @@ export default class Editor extends React.Component {
    * and need to find a workaround.
    */
   registerEditorForActions(editorView, eventDispatcher, contentTransformer) {
-    this.editorActions._privateRegisterEditor(editorView, eventDispatcher, contentTransformer);
+    this.editorActions._privateRegisterEditor(editorView, eventDispatcher, contentTransformer, this.getFeatureFlags);
   }
-
   /**
    * @private
    * @deprecated - Do not override this at all, this is an antipattern.

package/dist/es2019/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/es2019/labs/next/internal/hooks/use-editor/index.js

@@ -3,8 +3,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';
@@ -13,7 +12,7 @@ export function useEditor(config) {
   startMeasure(measurements.EDITOR_MOUNTED);
   const [editorSharedConfig, mountEditor] = useCreateEditor(config);
   useApplyEditorViewProps(editorSharedConfig, config.disabled);
-  useHandleEditorLifecycle(editorSharedConfig);
+  useHandleEditorLifecycle(editorSharedConfig, config.featureFlags);
   useAnalyticsHandler(editorSharedConfig);
   return [editorSharedConfig, mountEditor];
 }
@@ -109,7 +108,7 @@ function useApplyEditorViewProps(editorSharedConfig, disabled) {
 /**
  * Handles editor component unmount
  */
-export function useHandleEditorLifecycle(editorSharedConfig) {
+export function useHandleEditorLifecycle(editorSharedConfig, featureFlags) {
   React.useEffect(() => {
     //#region Did mount
     if (editorSharedConfig) {
@@ -124,7 +123,6 @@ export function useHandleEditorLifecycle(editorSharedConfig) {
       if (onMount) {
         onMount(editorActions);
       }
-      const featureFlags = getFeatureFlags(editorSharedConfig.editorView.state);
       const featureFlagsEnabled = featureFlags ? getEnabledFeatureFlagKeys(featureFlags) : [];
 
       // Fire editor started event
@@ -177,5 +175,5 @@ export function useHandleEditorLifecycle(editorSharedConfig) {
         editorView.destroy();
       }
     };
-  }, [editorSharedConfig]);
+  }, [editorSharedConfig, featureFlags]);
 }

package/dist/es2019/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/es2019/plugins/card/index.js

@@ -1,9 +1,10 @@
-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';
 const cardPlugin = (options, api) => {
   var _api$dependencies, _api$dependencies$fea;
   const 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()) || {};
@@ -26,17 +27,21 @@ const cardPlugin = (options, api) => {
       return nodes;
     },
     pmPlugins() {
-      var _options$allowBlockCa, _options$allowResizin, _options$useAlternati;
+      var _options$allowBlockCa, _options$allowResizin, _options$useAlternati, _options$allowWrappin, _options$allowAlignme;
       const allowBlockCards = (_options$allowBlockCa = options.allowBlockCards) !== null && _options$allowBlockCa !== void 0 ? _options$allowBlockCa : true;
       const allowResizing = (_options$allowResizin = options.allowResizing) !== null && _options$allowResizin !== void 0 ? _options$allowResizin : true;
       const useAlternativePreloader = (_options$useAlternati = options.useAlternativePreloader) !== null && _options$useAlternati !== void 0 ? _options$useAlternati : true;
+      const allowWrapping = (_options$allowWrappin = options.allowWrapping) !== null && _options$allowWrappin !== void 0 ? _options$allowWrappin : true;
+      const allowAlignment = (_options$allowAlignme = options.allowAlignment) !== null && _options$allowAlignme !== void 0 ? _options$allowAlignme : true;
       const plugins = [{
         name: 'card',
         plugin: createPlugin({
           ...options,
           allowBlockCards,
           allowResizing,
-          useAlternativePreloader
+          useAlternativePreloader,
+          allowWrapping,
+          allowAlignment
         })
       }];
       plugins.push({
@@ -52,9 +57,14 @@ const cardPlugin = (options, api) => {
     contentComponent({
       editorView
     }) {
-      return /*#__PURE__*/React.createElement(EditorSmartCardEvents, {
+      const {
+        lpAnalyticsEventsNext
+      } = featureFlags;
+      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/es2019/plugins/card/pm-plugins/actions.js

@@ -18,6 +18,10 @@ export const registerSmartCardEvents = smartLinkEvents => tr => cardAction(tr, {
   type: 'REGISTER_EVENTS',
   smartLinkEvents
 });
+export const registerSmartCardEventsNext = smartLinkEvents => tr => cardAction(tr, {
+  type: 'REGISTER_EVENTS_NEXT',
+  smartLinkEvents
+});
 export const setProvider = cardProvider => tr => cardAction(tr, {
   type: 'SET_PROVIDER',
   provider: cardProvider

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

@@ -0,0 +1,38 @@
+/**
+ * Simple mechanism to defer analytics related callbacks
+ */
+export const createAnalyticsQueue = (enabled = true) => {
+  const queue = [];
+  const callbacksRef = {
+    current: null
+  };
+  const setCallbacks = callbacks => {
+    callbacksRef.current = callbacks;
+  };
+  const push = (...events) => {
+    const callbacks = callbacksRef.current;
+    if (!enabled || !callbacks) {
+      return;
+    }
+    queue.push(...events);
+  };
+  const flush = () => {
+    const callbacks = callbacksRef.current;
+    if (!enabled || !callbacks) {
+      return;
+    }
+    while (queue.length) {
+      const event = queue.pop();
+      if (event) {
+        callbacks[event.type](event.data);
+      }
+    }
+  };
+  const getSize = () => queue.length;
+  return {
+    push,
+    flush,
+    setCallbacks,
+    getSize
+  };
+};

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

@@ -0,0 +1,316 @@
+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';
+const findLinksInNodeRange = (node, schema, from, to) => {
+  const links = [];
+  node.nodesBetween(from, to, (node, pos) => {
+    if (isLink(schema, node)) {
+      const entireLinkInRange = pos >= from && pos + node.nodeSize <= to;
+      if (entireLinkInRange) {
+        const link = linkObjectFromNode(schema, node, pos);
+        if (link) {
+          links.push(link);
+        }
+      }
+    }
+  });
+  return links;
+};
+export const findChangedLinks = (tr, state) => {
+  const schema = tr.doc.type.schema;
+  const removed = [];
+  const inserted = [];
+  const updated = [];
+  const queuedForUpgrade = isTransactionQueuedForUpgrade(tr);
+  const isResolveReplace = isTransactionResolveReplace(tr);
+
+  // History
+  const historyMeta = tr.getMeta(pmHistoryPluginKey);
+  const isUndo = isHistoryMeta(historyMeta) && historyMeta.redo === false;
+  const isRedo = isHistoryMeta(historyMeta) && historyMeta.redo === true;
+  const isUpdate = isUpdateTr(tr, isUndo || isRedo);
+  for (let i = 0; i < tr.steps.length; i++) {
+    const step = tr.steps[i];
+    const stepMap = step.getMap();
+    const removedInStep = [];
+    const 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) {
+      const 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) {
+      const 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((oldStart, oldEnd, newStart, newEnd) => {
+      var _tr$docs;
+      const before = tr.docs[i];
+      const after = (_tr$docs = tr.docs[i + 1]) !== null && _tr$docs !== void 0 ? _tr$docs : tr.doc;
+      const removedInRange = [];
+      const insertedInRange = [];
+
+      // Removed
+      removedInRange.push(...findLinksInNodeRange(before, schema, oldStart, oldEnd));
+      // Inserted
+      insertedInRange.push(...findLinksInNodeRange(after, schema, newStart, newEnd));
+      removedInStep.push(...removedInRange);
+      insertedInStep.push(...insertedInRange);
+    });
+    const omitQueuedLinks = links => {
+      if (!queuedForUpgrade) {
+        return links;
+      }
+      /**
+       * Skip/filter out links that have been queued, they will be tracked later
+       */
+      const queuedPositions = getQueuedPositions(tr);
+      return links.filter(link => !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(...removedInStep);
+    }
+    inserted.push(...omitQueuedLinks(insertedInStep));
+  }
+
+  /**
+   * 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) {
+    const positions = getResolvePositions(tr, state);
+    inserted.push(...findLinksAtPositions(tr, positions));
+  }
+  if (!isUpdate) {
+    return {
+      removed,
+      inserted,
+      updated
+    };
+  }
+  for (let i = 0; i < inserted.length; i++) {
+    if (isResolveReplace) {
+      const newLink = inserted[i];
+
+      // what is the 2nd argument 'assoc = -1' doing here exactly?
+      const mappedPos = tr.mapping.map(newLink.pos, -1);
+      const 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
+  };
+};
+
+/**
+ * List of actions to be considered link "updates"
+ */
+const 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
+ */
+const isUpdateTr = (tr, isUndoOrRedo) => {
+  return !!tr.steps.find(step => {
+    if (!(step instanceof LinkMetaStep)) {
+      return false;
+    }
+    const {
+      action,
+      cardAction
+    } = step.getMetadata();
+
+    /**
+     * 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);
+  });
+};
+const hasType = pluginMeta => {
+  return typeof pluginMeta === 'object' && pluginMeta !== null && 'type' in pluginMeta;
+};
+const isTransactionQueuedForUpgrade = tr => {
+  const pluginMeta = tr.getMeta(pluginKey);
+  return hasType(pluginMeta) && pluginMeta.type === 'QUEUE';
+};
+const isTransactionResolveReplace = tr => {
+  const pluginMeta = tr.getMeta(pluginKey);
+  return hasType(pluginMeta) && pluginMeta.type === 'RESOLVE';
+};
+const isHistoryMeta = meta => {
+  return typeof meta === 'object' && meta !== null && 'redo' in meta;
+};
+const getQueuedPositions = tr => {
+  const pluginMeta = tr.getMeta(pluginKey);
+  if (!isTransactionQueuedForUpgrade(tr)) {
+    return [];
+  }
+  return pluginMeta.requests.map(({
+    pos
+  }) => pos);
+};
+const getResolvePositions = (tr, state) => {
+  const cardState = getPluginState(state);
+  if (!cardState) {
+    return [];
+  }
+  const pluginMeta = tr.getMeta(pluginKey);
+  if (!isTransactionResolveReplace(tr)) {
+    return [];
+  }
+  return cardState.requests.filter(request => request.url === pluginMeta.url).map(request => request.pos);
+};
+const getResolveLinkPrevDisplay = (state, pos) => {
+  var _cardState$requests$f;
+  const cardState = getPluginState(state);
+  if (!cardState) {
+    return undefined;
+  }
+  return (_cardState$requests$f = cardState.requests.find(request => request.pos === pos)) === null || _cardState$requests$f === void 0 ? void 0 : _cardState$requests$f.previousAppearance;
+};
+export function eventsFromTransaction(tr, state) {
+  const 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
+     */
+    const isRemote = tr.getMeta('isRemote');
+    const isReplaceDocument = tr.getMeta('replaceDocument');
+    if (isRemote || isReplaceDocument) {
+      return events;
+    }
+    const historyMeta = tr.getMeta(pmHistoryPluginKey);
+    const isUndo = isHistoryMeta(historyMeta) && historyMeta.redo === false;
+    const isRedo = isHistoryMeta(historyMeta) && historyMeta.redo === true;
+
+    /**
+     * Retrieve metadata from the LinkMetaStep(s) in the transaction
+     */
+    const {
+      action,
+      inputMethod,
+      sourceEvent
+    } = getLinkMetadataFromTransaction(tr);
+    const contextualData = {
+      action,
+      inputMethod,
+      sourceEvent,
+      isUndo,
+      isRedo
+    };
+    const {
+      removed,
+      inserted,
+      updated
+    } = findChangedLinks(tr, state);
+    const MAX_LINK_EVENTS = 10;
+    if ([removed, inserted, updated].some(arr => arr.length > MAX_LINK_EVENTS)) {
+      return [];
+    }
+    for (let i = 0; i < updated.length; i++) {
+      var _update$previous$disp;
+      const update = updated[i];
+      const {
+        inserted: link
+      } = update;
+      const url = getLinkUrl(link);
+      const display = appearanceForLink(link);
+      const 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: {
+            ...contextualData,
+            url,
+            display,
+            previousDisplay
+          }
+        });
+      }
+    }
+    const pushEvents = (links, type) => {
+      for (let i = 0; i < links.length; i++) {
+        const link = links[i];
+        const url = getLinkUrl(link);
+        const display = appearanceForLink(link);
+        if (url) {
+          events.push({
+            type,
+            data: {
+              ...contextualData,
+              url,
+              display
+            }
+          });
+        }
+      }
+    };
+    pushEvents(removed, 'deleted');
+    pushEvents(inserted, 'created');
+    return events;
+  } catch (err) {
+    return events;
+  }
+}

package/dist/es2019/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/es2019/plugins/card/pm-plugins/analytics/types.js

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

package/dist/es2019/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') {
+    const appearance = appearanceForNodeType(link.node.type);
+    if (appearance) {
+      return appearance;
+    }
+  }
+  return 'url';
+}
+const nodeHasLinkMark = (schema, node) => {
+  if (node.marks) {
+    for (let i = 0; i < node.marks.length; i++) {
+      const mark = node.marks[i];
+      if (isLinkMark(mark, schema)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+/**
+ * Determine if a node is considered to be a link
+ */
+export const 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) {
+  const links = [];
+  node.descendants((node, pos) => {
+    // Nodes
+    if (isLinkNode(node)) {
+      links.push({
+        type: 'node',
+        pos: pos + offset,
+        node
+      });
+    }
+
+    // Marks
+    if (node.marks) {
+      for (let i = 0; i < node.marks.length; i++) {
+        const mark = node.marks[i];
+        if (isLinkMark(mark, schema)) {
+          links.push({
+            type: 'mark',
+            pos: pos + offset,
+            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 const linkObjectFromNode = (schema, node, pos) => {
+  if (isLinkNode(node)) {
+    return {
+      type: 'node',
+      pos,
+      node
+    };
+  }
+  if (node.marks) {
+    for (let i = 0; i < node.marks.length; i++) {
+      const mark = node.marks[i];
+      if (isLinkMark(mark, schema)) {
+        return {
+          type: 'mark',
+          pos,
+          mark
+        };
+      }
+    }
+  }
+};
+export const findLinksAtPositions = (tr, positions) => {
+  const schema = tr.doc.type.schema;
+  const links = [];
+  for (let i = 0; i < positions.length; i++) {
+    const pos = positions[i];
+    const node = tr.doc.nodeAt(pos);
+    if (!node) {
+      continue;
+    }
+    const link = linkObjectFromNode(schema, node, pos);
+    if (!link) {
+      continue;
+    }
+    links.push(link);
+  }
+  return links;
+};