@atlaskit/editor-plugin-media/dist/esm/commands/linking.js

Media plugin for @atlaskit/editor-core

import _defineProperty from "@babel/runtime/helpers/defineProperty";
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
import { createToggleBlockMarkOnRange } from '@atlaskit/editor-common/commands';
import { normalizeUrl } from '@atlaskit/editor-common/utils';
import { createMediaLinkingCommand, getMediaLinkingState, mediaLinkingPluginKey } from '../pm-plugins/linking';
import { MediaLinkingActionsTypes } from '../pm-plugins/linking/actions';
import { getMediaPluginState } from '../pm-plugins/main';
import { checkMediaType } from '../utils/check-media-type';
import { currentMediaNode } from '../utils/current-media-node';
export var showLinkingToolbar = createMediaLinkingCommand(function (state) {
  var mediaLinkingState = getMediaLinkingState(state);
  if (mediaLinkingState && mediaLinkingState.mediaPos !== null) {
    var mediaSingle = state.doc.nodeAt(mediaLinkingState.mediaPos);
    if (mediaSingle) {
      return {
        type: MediaLinkingActionsTypes.showToolbar
      };
    }
  }
  return false;
});
export var showLinkingToolbarWithMediaTypeCheck = function showLinkingToolbarWithMediaTypeCheck(editorState, dispatch, editorView) {
  if (dispatch && editorView) {
    var mediaNode = currentMediaNode(editorState);
    if (!mediaNode) {
      return false;
    }
    var _getMediaPluginState = getMediaPluginState(editorState),
      mediaClientConfig = _getMediaPluginState.mediaClientConfig;
    if (!mediaClientConfig) {
      return false;
    }
    checkMediaType(mediaNode, mediaClientConfig).then(function (mediaType) {
      if ((mediaType === 'external' || mediaType === 'image') &&
      // We make sure the selection and the node hasn't changed.
      currentMediaNode(editorView.state) === mediaNode) {
        dispatch(editorView.state.tr.setMeta(mediaLinkingPluginKey, {
          type: MediaLinkingActionsTypes.showToolbar
        }));
      }
    });
  }
  return true;
};
var hideLinkingToolbarCommand = createMediaLinkingCommand({
  type: MediaLinkingActionsTypes.hideToolbar
});
export var hideLinkingToolbar = function hideLinkingToolbar(state, dispatch, view, focusFloatingToolbar) {
  hideLinkingToolbarCommand(state, dispatch, view);

  // restore focus on the editor so keyboard shortcuts aren't lost to the browser
  if (view && !focusFloatingToolbar) {
    view.focus();
  }
};
function getCurrentUrl(state) {
  var linkType = state.schema.marks.link;
  var mediaLinkingState = getMediaLinkingState(state);
  if (!mediaLinkingState || mediaLinkingState.mediaPos === null) {
    return;
  }
  var $pos = state.doc.resolve(mediaLinkingState.mediaPos);
  var node = state.doc.nodeAt($pos.pos);
  if (!node) {
    return;
  }
  var hasLink = linkType.isInSet(node.marks);
  if (!hasLink) {
    return;
  }
  var link = node.marks.find(function (mark) {
    return mark.type === linkType;
  }); // Already check exist
  var url = link.attrs.href;
  return url;
}
function toggleLinkMark(tr, state, _ref) {
  var _ref$forceRemove = _ref.forceRemove,
    forceRemove = _ref$forceRemove === void 0 ? false : _ref$forceRemove,
    url = _ref.url;
  var mediaLinkingState = getMediaLinkingState(state);
  if (!mediaLinkingState || mediaLinkingState.mediaPos === null) {
    return tr;
  }
  var $pos = state.doc.resolve(mediaLinkingState.mediaPos);
  var node = state.doc.nodeAt($pos.pos);
  if (!node) {
    return tr;
  }
  var linkMark = state.schema.marks.link;
  var media = state.schema.nodes.media;
  var toggleBlockLinkMark = createToggleBlockMarkOnRange(linkMark, function (prevAttrs, node) {
    // Only add mark to media
    if (!node || node.type !== media) {
      return; //No op
    }

    if (forceRemove) {
      return false;
    }
    var href = normalizeUrl(url);
    if (prevAttrs && prevAttrs.href === href) {
      return; //No op
    }

    if (href.trim() === '') {
      return false; // remove
    }

    return _objectSpread(_objectSpread({}, prevAttrs), {}, {
      href: href
    });
  }, [media]);
  toggleBlockLinkMark($pos.pos, $pos.pos + node.nodeSize, tr, state);
  return tr;
}
var fireAnalyticForMediaLink = function fireAnalyticForMediaLink(tr, action) {
  var attributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
  var editorAnalyticsAPI = arguments.length > 3 ? arguments[3] : undefined;
  editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
    action: action,
    eventType: EVENT_TYPE.TRACK,
    actionSubject: ACTION_SUBJECT.MEDIA,
    actionSubjectId: ACTION_SUBJECT_ID.LINK,
    attributes: attributes
  })(tr);
  return tr;
};
export var unlink = function unlink(editorAnalyticsAPI) {
  return createMediaLinkingCommand({
    type: MediaLinkingActionsTypes.unlink
  }, function (tr, state) {
    var transaction = toggleLinkMark(tr, state, {
      forceRemove: true
    });
    return fireAnalyticForMediaLink(transaction, ACTION.DELETED, undefined, editorAnalyticsAPI);
  });
};
var getAction = function getAction(newUrl, state) {
  var currentUrl = getCurrentUrl(state);
  if (!currentUrl) {
    return ACTION.ADDED;
  } else if (newUrl !== currentUrl) {
    return ACTION.EDITED;
  }
  return undefined;
};
export var setUrlToMedia = function setUrlToMedia(url, inputMethod, editorAnalyticsAPI) {
  return createMediaLinkingCommand({
    type: MediaLinkingActionsTypes.setUrl,
    payload: normalizeUrl(url)
  }, function (tr, state) {
    var action = getAction(url, state);
    if (!action) {
      return tr;
    }
    try {
      var toggleLinkMarkResult = toggleLinkMark(tr, state, {
        url: url
      });
      fireAnalyticForMediaLink(tr, action, action === ACTION.ADDED ? {
        inputMethod: inputMethod
      } : undefined, editorAnalyticsAPI);
      return toggleLinkMarkResult;
    } catch (e) {
      fireAnalyticForMediaLink(tr, ACTION.ERRORED, {
        action: action
      }, editorAnalyticsAPI);
      throw e;
    }
  });
};