@atlaskit/editor-plugin-media 0.2.0 → 0.3.1

package/dist/es2019/utils/media-common.js

@@ -0,0 +1,189 @@
+import { atTheBeginningOfBlock, atTheBeginningOfDoc, atTheEndOfBlock, endPositionOfParent, GapCursorSelection, startPositionOfParent } from '@atlaskit/editor-common/selection';
+import { createNewParagraphBelow, createParagraphNear } from '@atlaskit/editor-common/utils';
+import { deleteSelection, splitBlock } from '@atlaskit/editor-prosemirror/commands';
+import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
+import { findPositionOfNodeBefore } from '@atlaskit/editor-prosemirror/utils';
+import { isMediaBlobUrl } from '@atlaskit/media-client';
+const isTemporary = id => {
+  return id.indexOf('temporary:') === 0;
+};
+export const isMediaBlobUrlFromAttrs = attrs => {
+  return !!(attrs && attrs.type === 'external' && isMediaBlobUrl(attrs.url));
+};
+export const posOfMediaGroupNearby = state => {
+  return posOfParentMediaGroup(state) || posOfFollowingMediaGroup(state) || posOfPrecedingMediaGroup(state) || posOfMediaGroupNextToGapCursor(state);
+};
+export const isSelectionNonMediaBlockNode = state => {
+  const {
+    node
+  } = state.selection;
+  return node && node.type !== state.schema.nodes.media && node.isBlock;
+};
+export const isSelectionMediaSingleNode = state => {
+  const {
+    node
+  } = state.selection;
+  return node && node.type === state.schema.nodes.mediaSingle;
+};
+export const posOfPrecedingMediaGroup = state => {
+  if (!atTheBeginningOfBlock(state)) {
+    return;
+  }
+  return posOfMediaGroupAbove(state, state.selection.$from);
+};
+const posOfMediaGroupNextToGapCursor = state => {
+  const {
+    selection
+  } = state;
+  if (selection instanceof GapCursorSelection) {
+    const $pos = state.selection.$from;
+    const mediaGroupType = state.schema.nodes.mediaGroup;
+    return posOfImmediatePrecedingMediaGroup($pos, mediaGroupType) || posOfImmediateFollowingMediaGroup($pos, mediaGroupType);
+  }
+};
+const posOfImmediatePrecedingMediaGroup = ($pos, mediaGroupType) => {
+  if ($pos.nodeBefore && $pos.nodeBefore.type === mediaGroupType) {
+    return $pos.pos - $pos.nodeBefore.nodeSize + 1;
+  }
+};
+const posOfImmediateFollowingMediaGroup = ($pos, mediaGroupType) => {
+  if ($pos.nodeAfter && $pos.nodeAfter.type === mediaGroupType) {
+    return $pos.pos + 1;
+  }
+};
+const posOfFollowingMediaGroup = state => {
+  if (!atTheEndOfBlock(state)) {
+    return;
+  }
+  return posOfMediaGroupBelow(state, state.selection.$to);
+};
+const posOfMediaGroupAbove = (state, $pos) => {
+  let adjacentPos;
+  let adjacentNode;
+  if (isSelectionNonMediaBlockNode(state)) {
+    adjacentPos = $pos.pos;
+    adjacentNode = $pos.nodeBefore;
+  } else {
+    adjacentPos = startPositionOfParent($pos) - 1;
+    adjacentNode = state.doc.resolve(adjacentPos).nodeBefore;
+  }
+  if (adjacentNode && adjacentNode.type === state.schema.nodes.mediaGroup) {
+    return adjacentPos - adjacentNode.nodeSize + 1;
+  }
+  return;
+};
+
+/**
+ * Determine whether the cursor is inside empty paragraph
+ * or the selection is the entire paragraph
+ */
+export const isInsidePotentialEmptyParagraph = state => {
+  const {
+    $from
+  } = state.selection;
+  return $from.parent.type === state.schema.nodes.paragraph && atTheBeginningOfBlock(state) && atTheEndOfBlock(state);
+};
+const posOfMediaGroupBelow = (state, $pos, prepend = true) => {
+  let adjacentPos;
+  let adjacentNode;
+  if (isSelectionNonMediaBlockNode(state)) {
+    adjacentPos = $pos.pos;
+    adjacentNode = $pos.nodeAfter;
+  } else {
+    adjacentPos = endPositionOfParent($pos);
+    adjacentNode = state.doc.nodeAt(adjacentPos);
+  }
+  if (adjacentNode && adjacentNode.type === state.schema.nodes.mediaGroup) {
+    return prepend ? adjacentPos + 1 : adjacentPos + adjacentNode.nodeSize - 1;
+  }
+  return;
+};
+export const posOfParentMediaGroup = (state, $pos, prepend = false) => {
+  const {
+    $from
+  } = state.selection;
+  $pos = $pos || $from;
+  if ($pos.parent.type === state.schema.nodes.mediaGroup) {
+    return prepend ? startPositionOfParent($pos) : endPositionOfParent($pos) - 1;
+  }
+  return;
+};
+export const removeMediaNode = (view, node, getPos) => {
+  const {
+    id
+  } = node.attrs;
+  const {
+    state
+  } = view;
+  const {
+    tr,
+    selection,
+    doc
+  } = state;
+  const currentMediaNodePos = getPos();
+  if (typeof currentMediaNodePos !== 'number') {
+    return;
+  }
+  tr.deleteRange(currentMediaNodePos, currentMediaNodePos + node.nodeSize);
+  if (isTemporary(id)) {
+    tr.setMeta('addToHistory', false);
+  }
+  const $currentMediaNodePos = doc.resolve(currentMediaNodePos);
+  const {
+    nodeBefore,
+    parent
+  } = $currentMediaNodePos;
+  const isLastMediaNode = $currentMediaNodePos.index() === parent.childCount - 1;
+
+  // If deleting a selected media node, we need to tell where the cursor to go next.
+  // Prosemirror didn't gave us the behaviour of moving left if the media node is not the last one.
+  // So we handle it ourselves.
+  if (selection.from === currentMediaNodePos && !isLastMediaNode && !atTheBeginningOfDoc(state) && nodeBefore && nodeBefore.type.name === 'media') {
+    const nodeBefore = findPositionOfNodeBefore(tr.selection);
+    if (nodeBefore) {
+      tr.setSelection(NodeSelection.create(tr.doc, nodeBefore));
+    }
+  }
+  view.dispatch(tr);
+};
+export const splitMediaGroup = view => {
+  const {
+    selection
+  } = view.state;
+
+  // if selection is not a media node, do nothing.
+  if (!(selection instanceof NodeSelection) || selection.node.type !== view.state.schema.nodes.media) {
+    return false;
+  }
+  deleteSelection(view.state, view.dispatch);
+  if (selection.$to.nodeAfter) {
+    splitBlock(view.state, view.dispatch);
+    createParagraphNear(false)(view.state, view.dispatch);
+  } else {
+    createNewParagraphBelow(view.state, view.dispatch);
+  }
+  return true;
+};
+const isOptionalAttr = attr => attr.length > 1 && attr[0] === '_' && attr[1] === '_';
+export const copyOptionalAttrsFromMediaState = (mediaState, node) => {
+  Object.keys(node.attrs).filter(isOptionalAttr).forEach(key => {
+    const mediaStateKey = key.substring(2);
+    const attrValue = mediaState[mediaStateKey];
+    if (attrValue !== undefined) {
+      // @ts-ignore - [unblock prosemirror bump] assigning to readonly prop
+      node.attrs[key] = attrValue;
+    }
+  });
+};
+export const getMediaNodeFromSelection = state => {
+  if (!isSelectionMediaSingleNode(state)) {
+    return null;
+  }
+  const tr = state.tr;
+  const pos = tr.selection.from + 1;
+  const mediaNode = tr.doc.nodeAt(pos);
+  if (mediaNode && mediaNode.type === state.schema.nodes.media) {
+    return mediaNode;
+  }
+  return null;
+};

package/dist/es2019/utils/media-files.js

@@ -0,0 +1,321 @@
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { atTheBeginningOfBlock, atTheEndOfBlock, atTheEndOfDoc, endPositionOfParent, startPositionOfParent } from '@atlaskit/editor-common/selection';
+import { findFarthestParentNode, insideTableCell, isInLayoutColumn, isInListItem, isSupportedInParent, setNodeSelection, setTextSelection } from '@atlaskit/editor-common/utils';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { canInsert, hasParentNode, safeInsert } from '@atlaskit/editor-prosemirror/utils';
+import { copyOptionalAttrsFromMediaState, isInsidePotentialEmptyParagraph, isSelectionNonMediaBlockNode, posOfMediaGroupNearby, posOfParentMediaGroup, posOfPrecedingMediaGroup } from './media-common';
+export const canInsertMediaInline = state => {
+  const node = state.schema.nodes.mediaInline.create({});
+  return canInsert(state.selection.$to, Fragment.from(node));
+};
+const getInsertMediaGroupAnalytics = (mediaState, inputMethod) => {
+  let media = '';
+  if (mediaState.length === 1) {
+    media = mediaState[0].fileMimeType || 'unknown';
+  } else if (mediaState.length > 1) {
+    media = 'multiple';
+  }
+  return {
+    action: ACTION.INSERTED,
+    actionSubject: ACTION_SUBJECT.DOCUMENT,
+    actionSubjectId: ACTION_SUBJECT_ID.MEDIA,
+    attributes: {
+      type: ACTION_SUBJECT_ID.MEDIA_GROUP,
+      inputMethod,
+      fileExtension: media
+    },
+    eventType: EVENT_TYPE.TRACK
+  };
+};
+const getInsertMediaInlineAnalytics = (mediaState, inputMethod) => {
+  const media = mediaState.fileMimeType || 'unknown';
+  return {
+    action: ACTION.INSERTED,
+    actionSubject: ACTION_SUBJECT.DOCUMENT,
+    actionSubjectId: ACTION_SUBJECT_ID.MEDIA,
+    attributes: {
+      type: ACTION_SUBJECT_ID.MEDIA_INLINE,
+      inputMethod,
+      fileExtension: media
+    },
+    eventType: EVENT_TYPE.TRACK
+  };
+};
+
+/**
+ * Check if current editor selections is a media group or not.
+ * @param state Editor state
+ */
+function isSelectionMediaGroup(state) {
+  const {
+    schema
+  } = state;
+  const selectionParent = state.selection.$anchor.node();
+  return selectionParent && selectionParent.type === schema.nodes.mediaGroup;
+}
+
+/**
+ * Insert a paragraph after if reach the end of doc
+ * and there is no media group in the front or selection is a non media block node
+ * @param node Node at insertion point
+ * @param state Editor state
+ */
+function shouldAppendParagraph(state, node) {
+  const {
+    schema: {
+      nodes: {
+        media
+      }
+    }
+  } = state;
+  const wasMediaNode = node && node.type === media;
+  return (insideTableCell(state) || isInListItem(state) || isInLayoutColumn(state) || atTheEndOfDoc(state) && (!posOfPrecedingMediaGroup(state) || isSelectionNonMediaBlockNode(state))) && !wasMediaNode;
+}
+
+/**
+ * Create a new media inline to insert the new media.
+ * @param view Editor view
+ * @param mediaState Media file to be added to the editor
+ * @param collection Collection for the media to be added
+ */
+export const insertMediaInlineNode = editorAnalyticsAPI => (view, mediaState, collection, inputMethod) => {
+  const {
+    state,
+    dispatch
+  } = view;
+  const {
+    schema,
+    tr
+  } = state;
+  const {
+    mediaInline
+  } = schema.nodes;
+
+  // Do nothing if no media found
+  if (!mediaInline || !mediaState || collection === undefined) {
+    return false;
+  }
+  const {
+    id
+  } = mediaState;
+  const mediaInlineNode = mediaInline.create({
+    id,
+    collection
+  });
+  const space = state.schema.text(' ');
+  let pos = state.selection.$to.pos;
+
+  // If the selection is inside an empty list item set pos inside paragraph
+  if (isInListItem(state) && isInsidePotentialEmptyParagraph(state)) {
+    pos = pos + 1;
+  }
+  let content = Fragment.from([mediaInlineNode, space]);
+
+  // Delete the selection if a selection is made
+  const deleteRange = findDeleteRange(state);
+  if (!deleteRange) {
+    tr.insert(pos, content);
+  } else {
+    tr.insert(pos, content).deleteRange(deleteRange.start, deleteRange.end);
+  }
+  editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(getInsertMediaInlineAnalytics(mediaState, inputMethod))(tr);
+  dispatch(tr);
+  return true;
+};
+
+/**
+ * Insert a media into an existing media group
+ * or create a new media group to insert the new media.
+ * @param view Editor view
+ * @param mediaStates Media files to be added to the editor
+ * @param collection Collection for the media to be added
+ */
+export const insertMediaGroupNode = editorAnalyticsAPI => (view, mediaStates, collection, inputMethod) => {
+  const {
+    state,
+    dispatch
+  } = view;
+  const {
+    tr,
+    schema
+  } = state;
+  const {
+    media,
+    paragraph
+  } = schema.nodes;
+
+  // Do nothing if no media found
+  if (!media || !mediaStates.length) {
+    return;
+  }
+  const mediaNodes = createMediaFileNodes(mediaStates, collection, media);
+  const mediaInsertPos = findMediaInsertPos(state);
+  const resolvedInsertPos = tr.doc.resolve(mediaInsertPos);
+  const parent = resolvedInsertPos.parent;
+  const nodeAtInsertionPoint = tr.doc.nodeAt(mediaInsertPos);
+  const shouldSplit = !isSelectionMediaGroup(state) && isSupportedInParent(state, Fragment.from(state.schema.nodes.mediaGroup.createChecked({}, mediaNodes)));
+  const withParagraph = shouldAppendParagraph(state, nodeAtInsertionPoint);
+  let content = parent.type === schema.nodes.mediaGroup ? mediaNodes // If parent is a mediaGroup do not wrap items again.
+  : [schema.nodes.mediaGroup.createChecked({}, mediaNodes)];
+  if (shouldSplit) {
+    content = withParagraph ? content.concat(paragraph.create()) : content;
+    // delete the selection or empty paragraph
+    const deleteRange = findDeleteRange(state);
+    if (!deleteRange) {
+      tr.insert(mediaInsertPos, content);
+    } else if (mediaInsertPos <= deleteRange.start) {
+      tr.deleteRange(deleteRange.start, deleteRange.end).insert(mediaInsertPos, content);
+    } else {
+      tr.insert(mediaInsertPos, content).deleteRange(deleteRange.start, deleteRange.end);
+    }
+    editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(getInsertMediaGroupAnalytics(mediaStates, inputMethod))(tr);
+    dispatch(tr);
+    setSelectionAfterMediaInsertion(view);
+    return;
+  }
+
+  // Don't append new paragraph when adding media to a existing mediaGroup
+  if (withParagraph && parent.type !== schema.nodes.mediaGroup) {
+    content.push(paragraph.create());
+  }
+  editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(getInsertMediaGroupAnalytics(mediaStates, inputMethod))(tr);
+  dispatch(safeInsert(Fragment.fromArray(content), mediaInsertPos)(tr));
+};
+const createMediaFileNodes = (mediaStates, collection, media) => {
+  const nodes = mediaStates.map(mediaState => {
+    const {
+      id
+    } = mediaState;
+    const node = media.create({
+      id,
+      type: 'file',
+      collection
+    });
+    copyOptionalAttrsFromMediaState(mediaState, node);
+    return node;
+  });
+  return nodes;
+};
+
+/**
+ * Find root list node if exist from current selection
+ * @param state Editor state
+ */
+const findRootListNode = state => {
+  const {
+    schema: {
+      nodes: {
+        bulletList,
+        orderedList
+      }
+    }
+  } = state;
+  return findFarthestParentNode(node => node.type === bulletList || node.type === orderedList)(state.selection.$from);
+};
+
+/**
+ * Return position of media to be inserted, if it is inside a list
+ * @param content Content to be inserted
+ * @param state Editor State
+ */
+export const getPosInList = state => {
+  const {
+    schema: {
+      nodes: {
+        mediaGroup,
+        listItem
+      }
+    }
+  } = state;
+
+  // 1. Check if I am inside a list.
+  if (hasParentNode(node => node.type === listItem)(state.selection)) {
+    // 2. Get end position of root list
+    const rootListNode = findRootListNode(state);
+    if (rootListNode) {
+      const pos = rootListNode.pos + rootListNode.node.nodeSize;
+      // 3. Fint the first location inside the media group
+      const nextNode = state.doc.nodeAt(pos);
+      if (nextNode && nextNode.type === mediaGroup) {
+        return pos + 1;
+      }
+      return pos;
+    }
+  }
+  return;
+};
+
+/**
+ * Find insertion point,
+ * If it is in a List it will return position to the next block,
+ * If there are any media group close it will return this position
+ * Otherwise, It will return the respective block given selection.
+ * @param content Content to be inserted
+ * @param state Editor state
+ */
+const findMediaInsertPos = state => {
+  const {
+    $from,
+    $to
+  } = state.selection;
+
+  // Check if selection is inside a list.
+  const posInList = getPosInList(state);
+  if (posInList) {
+    // If I have a position in lists, I should return, otherwise I am not inside a list
+    return posInList;
+  }
+  const nearbyMediaGroupPos = posOfMediaGroupNearby(state);
+  if (nearbyMediaGroupPos && (!isSelectionNonMediaBlockNode(state) || $from.pos < nearbyMediaGroupPos && $to.pos < nearbyMediaGroupPos)) {
+    return nearbyMediaGroupPos;
+  }
+  if (isSelectionNonMediaBlockNode(state)) {
+    return $to.pos;
+  }
+  if (atTheEndOfBlock(state)) {
+    return $to.pos + 1;
+  }
+  if (atTheBeginningOfBlock(state)) {
+    return $from.pos - 1;
+  }
+  return $to.pos;
+};
+const findDeleteRange = state => {
+  const {
+    $from,
+    $to
+  } = state.selection;
+  if (posOfParentMediaGroup(state)) {
+    return;
+  }
+  if (!isInsidePotentialEmptyParagraph(state) || posOfMediaGroupNearby(state)) {
+    return range($from.pos, $to.pos);
+  }
+  return range(startPositionOfParent($from) - 1, endPositionOfParent($to));
+};
+const range = (start, end = start) => {
+  return {
+    start,
+    end
+  };
+};
+const setSelectionAfterMediaInsertion = view => {
+  const {
+    state
+  } = view;
+  const {
+    doc
+  } = state;
+  const mediaPos = posOfMediaGroupNearby(state);
+  if (!mediaPos) {
+    return;
+  }
+  const $mediaPos = doc.resolve(mediaPos);
+  const endOfMediaGroup = endPositionOfParent($mediaPos);
+  if (endOfMediaGroup + 1 >= doc.nodeSize - 1) {
+    // if nothing after the media group, fallback to select the newest uploaded media item
+    setNodeSelection(view, mediaPos);
+  } else {
+    setTextSelection(view, endOfMediaGroup + 1);
+  }
+};

package/dist/es2019/utils/media-single.js

@@ -0,0 +1,176 @@
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { safeInsert, shouldSplitSelectedNodeOnNodeInsertion } from '@atlaskit/editor-common/insert';
+import { getMaxWidthForNestedNodeNext, getMediaSingleInitialWidth, MEDIA_SINGLE_DEFAULT_MIN_PIXEL_WIDTH, MEDIA_SINGLE_VIDEO_MIN_PIXEL_WIDTH } from '@atlaskit/editor-common/media-single';
+import { atTheBeginningOfBlock } from '@atlaskit/editor-common/selection';
+import { checkNodeDown, isEmptyParagraph } from '@atlaskit/editor-common/utils';
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { safeInsert as pmSafeInsert } from '@atlaskit/editor-prosemirror/utils';
+import { getBooleanFF } from '@atlaskit/platform-feature-flags';
+import { copyOptionalAttrsFromMediaState } from '../utils/media-common';
+import { isImage } from './is-image';
+const getInsertMediaAnalytics = (inputMethod, fileExtension) => ({
+  action: ACTION.INSERTED,
+  actionSubject: ACTION_SUBJECT.DOCUMENT,
+  actionSubjectId: ACTION_SUBJECT_ID.MEDIA,
+  attributes: {
+    inputMethod,
+    fileExtension,
+    type: ACTION_SUBJECT_ID.MEDIA_SINGLE
+  },
+  eventType: EVENT_TYPE.TRACK
+});
+function shouldAddParagraph(state) {
+  return atTheBeginningOfBlock(state) && !checkNodeDown(state.selection, state.doc, isEmptyParagraph);
+}
+function insertNodesWithOptionalParagraph(nodes, analyticsAttributes = {}, editorAnalyticsAPI) {
+  return function (state, dispatch) {
+    const {
+      tr,
+      schema
+    } = state;
+    const {
+      paragraph
+    } = schema.nodes;
+    const {
+      inputMethod,
+      fileExtension
+    } = analyticsAttributes;
+    let openEnd = 0;
+    if (shouldAddParagraph(state)) {
+      nodes.push(paragraph.create());
+      openEnd = 1;
+    }
+    tr.replaceSelection(new Slice(Fragment.from(nodes), 0, openEnd));
+    if (inputMethod) {
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(getInsertMediaAnalytics(inputMethod, fileExtension))(tr);
+    }
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+export const isMediaSingle = (schema, fileMimeType) => !!schema.nodes.mediaSingle && isImage(fileMimeType);
+export const insertMediaAsMediaSingle = (view, node, inputMethod, editorAnalyticsAPI) => {
+  const {
+    state,
+    dispatch
+  } = view;
+  const {
+    mediaSingle,
+    media
+  } = state.schema.nodes;
+  if (!mediaSingle) {
+    return false;
+  }
+
+  // if not an image type media node
+  if (node.type !== media || !isImage(node.attrs.__fileMimeType) && node.attrs.type !== 'external') {
+    return false;
+  }
+  const mediaSingleNode = mediaSingle.create({}, node);
+  const nodes = [mediaSingleNode];
+  const analyticsAttributes = {
+    inputMethod,
+    fileExtension: node.attrs.__fileMimeType
+  };
+  return insertNodesWithOptionalParagraph(nodes, analyticsAttributes, editorAnalyticsAPI)(state, dispatch);
+};
+export const insertMediaSingleNode = (view, mediaState, inputMethod, collection, alignLeftOnInsert, newInsertionBehaviour, widthPluginState, editorAnalyticsAPI) => {
+  var _state$selection$$fro;
+  if (collection === undefined) {
+    return false;
+  }
+  const {
+    state,
+    dispatch
+  } = view;
+  const grandParentNodeType = (_state$selection$$fro = state.selection.$from.node(-1)) === null || _state$selection$$fro === void 0 ? void 0 : _state$selection$$fro.type;
+  const parentNodeType = state.selection.$from.parent.type;
+
+  // add undefined as fallback as we don't want media single width to have upper limit as 0
+  // if widthPluginState.width is 0, default 760 will be used
+  const contentWidth = getMaxWidthForNestedNodeNext(view, state.selection.$from.pos, true) || (widthPluginState === null || widthPluginState === void 0 ? void 0 : widthPluginState.lineLength) || (widthPluginState === null || widthPluginState === void 0 ? void 0 : widthPluginState.width) || undefined;
+  const node = createMediaSingleNode(state.schema, collection, contentWidth, mediaState.status !== 'error' && isVideo(mediaState.fileMimeType) ? MEDIA_SINGLE_VIDEO_MIN_PIXEL_WIDTH : MEDIA_SINGLE_DEFAULT_MIN_PIXEL_WIDTH, alignLeftOnInsert)(mediaState);
+  let fileExtension;
+  if (mediaState.fileName) {
+    const extensionIdx = mediaState.fileName.lastIndexOf('.');
+    fileExtension = extensionIdx >= 0 ? mediaState.fileName.substring(extensionIdx + 1) : undefined;
+  }
+  // should split if media is valid content for the grandparent of the selected node
+  // and the parent node is a paragraph
+  if (shouldSplitSelectedNodeOnNodeInsertion({
+    parentNodeType,
+    grandParentNodeType,
+    content: node
+  })) {
+    insertNodesWithOptionalParagraph([node], {
+      fileExtension,
+      inputMethod
+    }, editorAnalyticsAPI)(state, dispatch);
+  } else {
+    let tr = null;
+    if (newInsertionBehaviour) {
+      tr = safeInsert(node, state.selection.from)(state.tr);
+    }
+    if (!tr) {
+      const content = shouldAddParagraph(view.state) ? Fragment.fromArray([node, state.schema.nodes.paragraph.create()]) : node;
+      tr = pmSafeInsert(content, undefined, true)(state.tr);
+    }
+    if (inputMethod) {
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent(getInsertMediaAnalytics(inputMethod, fileExtension))(tr);
+    }
+    dispatch(tr);
+  }
+  return true;
+};
+export const createMediaSingleNode = (schema, collection, maxWidth, minWidth, alignLeftOnInsert) => mediaState => {
+  const {
+    id,
+    dimensions,
+    contextId,
+    scaleFactor = 1
+  } = mediaState;
+  const {
+    width,
+    height
+  } = dimensions || {
+    height: undefined,
+    width: undefined
+  };
+  const {
+    media,
+    mediaSingle
+  } = schema.nodes;
+  const scaledWidth = width && Math.round(width / scaleFactor);
+  const mediaNode = media.create({
+    id,
+    type: 'file',
+    collection,
+    contextId,
+    width: scaledWidth,
+    height: height && Math.round(height / scaleFactor)
+  });
+  const mediaSingleAttrs = alignLeftOnInsert ? {
+    layout: 'align-start'
+  } : {};
+  const extendedMediaSingleAttrs = getBooleanFF('platform.editor.media.extended-resize-experience') ? {
+    ...mediaSingleAttrs,
+    width: getMediaSingleInitialWidth(scaledWidth, maxWidth, minWidth),
+    // TODO: change to use enum
+    widthType: 'pixel'
+  } : mediaSingleAttrs;
+  copyOptionalAttrsFromMediaState(mediaState, mediaNode);
+  return mediaSingle.createChecked(extendedMediaSingleAttrs, mediaNode);
+};
+export function isCaptionNode(editorView) {
+  const {
+    $from
+  } = editorView.state.selection;
+  const immediateWrapperParentNode = editorView.state.doc.nodeAt($from.before(Math.max($from.depth, 1)));
+  if (immediateWrapperParentNode && immediateWrapperParentNode.type.name === 'caption') {
+    return true;
+  }
+  return false;
+}
+export const isVideo = fileType => !!fileType && fileType.includes('video');