@atlaskit/editor-core 181.0.1 → 182.0.0

package/dist/es2019/plugins/collab-edit/analytics.js

@@ -1,8 +1,7 @@
 import { addAnalytics, ACTION, EVENT_TYPE, ACTION_SUBJECT } from '../analytics';
-import { getFeatureFlags } from '../feature-flags-context';
 import { getDocStructure } from '../../utils/document-logger';
 import { sniffUserBrowserExtensions } from '@atlaskit/editor-common/utils';
-export const addSynchronyErrorAnalytics = (state, tr) => {
+export const addSynchronyErrorAnalytics = (state, tr, featureFlags) => {
   return error => {
     const browserExtensions = sniffUserBrowserExtensions({
       extensions: ['grammarly']
@@ -16,7 +15,7 @@ export const addSynchronyErrorAnalytics = (state, tr) => {
         browserExtensions
       }
     };
-    if (getFeatureFlags(state).synchronyErrorDocStructure) {
+    if (featureFlags.synchronyErrorDocStructure) {
       payload.attributes.docStructure = getDocStructure(state.doc, {
         compact: true
       });

package/dist/es2019/plugins/collab-edit/events/handlers.js

@@ -12,7 +12,7 @@ const effect = (fn, eq) => {
     return cleanup;
   };
 };
-export const subscribe = effect((view, provider, options, _providerFactory) => {
+export const subscribe = effect((view, provider, options, featureFlags, _providerFactory) => {
   let entityRef;
   const entityHandlers = {
     disconnectedHandler: () => {
@@ -51,7 +51,7 @@ export const subscribe = effect((view, provider, options, _providerFactory) => {
       view.dispatch(tr);
     },
     errorHandler: error => {
-      addSynchronyErrorAnalytics(view.state, view.state.tr)(error);
+      addSynchronyErrorAnalytics(view.state, view.state.tr, featureFlags)(error);
     },
     entityHandler: ({
       entity

package/dist/es2019/plugins/collab-edit/events/initialize.js

@@ -17,14 +17,15 @@ const initCollabMemo = memoizeOne(initCollab);
 export const initialize = ({
   options,
   providerFactory,
-  view
+  view,
+  featureFlags
 }) => provider => {
   let cleanup;
   const pluginState = pluginKey.getState(view.state);
   if (pluginState.isReady && cleanup) {
     cleanup();
   }
-  cleanup = subscribe(view, provider, options, providerFactory);
+  cleanup = subscribe(view, provider, options, featureFlags, providerFactory);
 
   // Initialize provider
   if (options.useNativePlugin) {

package/dist/es2019/plugins/collab-edit/index.js

@@ -19,7 +19,9 @@ const providerBuilder = collabEditProviderPromise => async (codeToExecute, onErr
     }
   }
 };
-const collabEditPlugin = options => {
+const collabEditPlugin = (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()) || {};
   let providerResolver = () => {};
   const collabEditProviderPromise = new Promise(_providerResolver => {
     providerResolver = _providerResolver;
@@ -53,12 +55,12 @@ const collabEditPlugin = options => {
               providerPromise.then(provider => providerResolver(provider));
             }
           });
-          return createPlugin(dispatch, providerFactory, executeProviderCode, options);
+          return createPlugin(dispatch, providerFactory, executeProviderCode, options, featureFlags);
         }
       }];
     },
     onEditorViewStateUpdated(props) {
-      const addErrorAnalytics = addSynchronyErrorAnalytics(props.newEditorState, props.newEditorState.tr);
+      const addErrorAnalytics = addSynchronyErrorAnalytics(props.newEditorState, props.newEditorState.tr, featureFlags);
       executeProviderCode(sendTransaction({
         originalTransaction: props.originalTransaction,
         transactions: props.transactions,

package/dist/es2019/plugins/collab-edit/plugin.js

@@ -5,7 +5,7 @@ import { pluginKey } from './plugin-key';
 import { addSynchronyErrorAnalytics } from './analytics';
 import { fireAnalyticsEvent, ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
 export { PluginState, pluginKey };
-export const createPlugin = (dispatch, providerFactory, collabProviderCallback, options) => {
+export const createPlugin = (dispatch, providerFactory, collabProviderCallback, options, featureFlags) => {
   const fireAnalyticsCallback = fireAnalyticsEvent(options === null || options === void 0 ? void 0 : options.createAnalyticsEvent);
   return new SafePlugin({
     key: pluginKey,
@@ -39,7 +39,7 @@ export const createPlugin = (dispatch, providerFactory, collabProviderCallback,
       return true;
     },
     view(view) {
-      const addErrorAnalytics = addSynchronyErrorAnalytics(view.state, view.state.tr);
+      const addErrorAnalytics = addSynchronyErrorAnalytics(view.state, view.state.tr, featureFlags);
       const onSyncUpError = attributes => {
         fireAnalyticsCallback({
           payload: {
@@ -54,7 +54,8 @@ export const createPlugin = (dispatch, providerFactory, collabProviderCallback,
       const cleanup = collabProviderCallback(initialize({
         view,
         options,
-        providerFactory
+        providerFactory,
+        featureFlags
       }), addErrorAnalytics);
       return {
         destroy() {

package/dist/es2019/plugins/collab-edit/ui/avatars-with-plugin-state.js

@@ -11,7 +11,8 @@ const AvatarsWithPluginState = props => {
     isInviteToEditButtonSelected: selected,
     inviteToEditHandler: onClick,
     inviteToEditComponent: Component,
-    editorView
+    editorView,
+    featureFlags
   } = props;
   const render = React.useCallback(({
     data
@@ -22,14 +23,15 @@ const AvatarsWithPluginState = props => {
     return /*#__PURE__*/React.createElement(Avatars, {
       sessionId: data.sessionId,
       participants: data.activeParticipants,
-      editorView: editorView
+      editorView: editorView,
+      featureFlags: featureFlags
     }, /*#__PURE__*/React.createElement(InviteToEditButton, {
       title: title,
       selected: selected,
       onClick: onClick,
       Component: Component
     }));
-  }, [selected, onClick, Component, title, editorView]);
+  }, [selected, onClick, Component, title, editorView, featureFlags]);
   return /*#__PURE__*/React.createElement(WithPluginState, {
     plugins: {
       data: collabEditPluginKey

package/dist/es2019/plugins/collab-edit/ui/avatars.js

@@ -5,11 +5,11 @@ import AvatarGroup from '@atlaskit/avatar-group';
 import { avatarContainer } from './styles';
 import toAvatar from './to-avatar';
 import { scrollToCollabCursor } from '../utils';
-import { getFeatureFlags } from '../../feature-flags-context';
 export const Avatars = /*#__PURE__*/React.memo(props => {
   const {
     sessionId,
-    editorView
+    editorView,
+    featureFlags
   } = props;
   const participants = props.participants.toArray();
   const avatars = participants.sort(p => p.sessionId === sessionId ? -1 : 1).map(toAvatar);
@@ -27,7 +27,6 @@ export const Avatars = /*#__PURE__*/React.memo(props => {
       if (!editorView) {
         return;
       }
-      const featureFlags = getFeatureFlags(editorView.state);
       const allowCollabAvatarScroll = featureFlags === null || featureFlags === void 0 ? void 0 : featureFlags.collabAvatarScroll;
 
       // user does not need to scroll to their own position (index 0)

package/dist/es2019/plugins/date/index.js

@@ -2,21 +2,103 @@ import React from 'react';
 import { findDomRefAtPos } from 'prosemirror-utils';
 import Loadable from 'react-loadable';
 import { date } from '@atlaskit/adf-schema';
-import WithPluginState from '../../ui/WithPluginState';
 import { insertDate, closeDatePicker, closeDatePickerWithAnalytics, createDate, deleteDate } from './actions';
 import createDatePlugin from './pm-plugins/main';
 import keymap from './pm-plugins/keymap';
-import { pluginKey as editorDisabledPluginKey } from '../editor-disabled';
 import { IconDate } from '../quick-insert/assets';
 import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, addAnalytics, EVENT_TYPE, INPUT_METHOD } from '../analytics';
 import { messages } from '../insert-block/ui/ToolbarInsertBlock/messages';
 import { pluginKey as datePluginKey } from './pm-plugins/plugin-key';
+import { useSharedPluginState } from '@atlaskit/editor-common/hooks';
 const DatePicker = Loadable({
   loader: () => import( /* webpackChunkName: "@atlaskit-internal_editor-datepicker" */'./ui/DatePicker').then(mod => mod.default),
   loading: () => null
 });
-const datePlugin = () => ({
+function ContentComponent({
+  editorView,
+  dispatchAnalyticsEvent,
+  popupsMountPoint,
+  popupsBoundariesElement,
+  popupsScrollableElement,
+  dependencyApi
+}) {
+  const {
+    dispatch
+  } = editorView;
+  const domAtPos = editorView.domAtPos.bind(editorView);
+  const {
+    editorDisabledState,
+    dateState
+  } = useSharedPluginState(dependencyApi, ['date', 'editorDisabled']);
+  if (!(dateState !== null && dateState !== void 0 && dateState.showDatePickerAt) || editorDisabledState !== null && editorDisabledState !== void 0 && editorDisabledState.editorDisabled) {
+    return null;
+  }
+  const {
+    showDatePickerAt,
+    isNew,
+    focusDateInput
+  } = dateState;
+  const element = findDomRefAtPos(showDatePickerAt, domAtPos);
+  return /*#__PURE__*/React.createElement(DatePicker, {
+    mountTo: popupsMountPoint,
+    boundariesElement: popupsBoundariesElement,
+    scrollableElement: popupsScrollableElement,
+    key: showDatePickerAt,
+    element: element,
+    isNew: isNew,
+    autoFocus: focusDateInput,
+    onDelete: () => {
+      deleteDate()(editorView.state, dispatch);
+      editorView.focus();
+      return;
+    },
+    onSelect: (date, commitMethod) => {
+      // Undefined means couldn't parse date, null means invalid (out of bounds) date
+      if (date === undefined || date === null) {
+        return;
+      }
+      insertDate(date, undefined, commitMethod)(editorView.state, dispatch);
+      editorView.focus();
+    },
+    onTextChanged: date => {
+      insertDate(date, undefined, undefined, false)(editorView.state, dispatch);
+    },
+    closeDatePicker: () => {
+      closeDatePicker()(editorView.state, dispatch);
+      editorView.focus();
+    },
+    closeDatePickerWithAnalytics: ({
+      date
+    }) => {
+      closeDatePickerWithAnalytics({
+        date
+      })(editorView.state, dispatch);
+      editorView.focus();
+    },
+    dispatchAnalyticsEvent: dispatchAnalyticsEvent
+  });
+}
+const datePlugin = (_, api) => ({
   name: 'date',
+  getSharedState(editorState) {
+    if (!editorState) {
+      return {
+        showDatePickerAt: null,
+        isNew: false,
+        focusDateInput: false
+      };
+    }
+    const {
+      showDatePickerAt,
+      isNew,
+      focusDateInput
+    } = datePluginKey.getState(editorState);
+    return {
+      showDatePickerAt,
+      isNew,
+      focusDateInput
+    };
+  },
   nodes() {
     return [{
       name: 'date',
@@ -45,67 +127,13 @@ const datePlugin = () => ({
     popupsBoundariesElement,
     popupsScrollableElement
   }) {
-    const {
-      dispatch
-    } = editorView;
-    const domAtPos = editorView.domAtPos.bind(editorView);
-    return /*#__PURE__*/React.createElement(WithPluginState, {
-      plugins: {
-        datePlugin: datePluginKey,
-        editorDisabledPlugin: editorDisabledPluginKey
-      },
-      render: ({
-        editorDisabledPlugin,
-        datePlugin
-      }) => {
-        if (!(datePlugin !== null && datePlugin !== void 0 && datePlugin.showDatePickerAt) || editorDisabledPlugin !== null && editorDisabledPlugin !== void 0 && editorDisabledPlugin.editorDisabled) {
-          return null;
-        }
-        const {
-          showDatePickerAt,
-          isNew,
-          focusDateInput
-        } = datePlugin;
-        const element = findDomRefAtPos(showDatePickerAt, domAtPos);
-        return /*#__PURE__*/React.createElement(DatePicker, {
-          mountTo: popupsMountPoint,
-          boundariesElement: popupsBoundariesElement,
-          scrollableElement: popupsScrollableElement,
-          key: showDatePickerAt,
-          element: element,
-          isNew: isNew,
-          autoFocus: focusDateInput,
-          onDelete: () => {
-            deleteDate()(editorView.state, dispatch);
-            editorView.focus();
-            return;
-          },
-          onSelect: (date, commitMethod) => {
-            // Undefined means couldn't parse date, null means invalid (out of bounds) date
-            if (date === undefined || date === null) {
-              return;
-            }
-            insertDate(date, undefined, commitMethod)(editorView.state, dispatch);
-            editorView.focus();
-          },
-          onTextChanged: date => {
-            insertDate(date, undefined, undefined, false)(editorView.state, dispatch);
-          },
-          closeDatePicker: () => {
-            closeDatePicker()(editorView.state, dispatch);
-            editorView.focus();
-          },
-          closeDatePickerWithAnalytics: ({
-            date
-          }) => {
-            closeDatePickerWithAnalytics({
-              date
-            })(editorView.state, dispatch);
-            editorView.focus();
-          },
-          dispatchAnalyticsEvent: dispatchAnalyticsEvent
-        });
-      }
+    return /*#__PURE__*/React.createElement(ContentComponent, {
+      dependencyApi: api,
+      editorView: editorView,
+      dispatchAnalyticsEvent: dispatchAnalyticsEvent,
+      popupsMountPoint: popupsMountPoint,
+      popupsBoundariesElement: popupsBoundariesElement,
+      popupsScrollableElement: popupsScrollableElement
     });
   },
   pluginsOptions: {

package/dist/es2019/plugins/editor-disabled/index.js

@@ -38,6 +38,14 @@ export function createPlugin(dispatch) {
 }
 const editorDisabledPlugin = () => ({
   name: 'editorDisabled',
+  getSharedState(editorState) {
+    if (!editorState) {
+      return {
+        editorDisabled: false
+      };
+    }
+    return pluginKey.getState(editorState);
+  },
   pmPlugins: () => [{
     name: 'editorDisabled',
     plugin: ({

package/dist/es2019/plugins/expand/index.js

@@ -7,63 +7,67 @@ import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, addAnalytics, EVENT_TYPE, IN
 import { getToolbarConfig } from './toolbar';
 import { createExpandNode } from './commands';
 import { messages } from '../insert-block/ui/ToolbarInsertBlock/messages';
-const expandPlugin = (options = {}) => ({
-  name: 'expand',
-  nodes() {
-    return [{
-      name: 'expand',
-      node: expand
-    }, {
-      name: 'nestedExpand',
-      node: nestedExpand
-    }];
-  },
-  pmPlugins() {
-    return [{
-      name: 'expand',
-      plugin: ({
-        dispatch,
-        getIntl
-      }) => {
-        return createPlugin(dispatch, getIntl, options.appearance, options.useLongPressSelection);
-      }
-    }, {
-      name: 'expandKeymap',
-      plugin: expandKeymap
-    }];
-  },
-  pluginsOptions: {
-    floatingToolbar: getToolbarConfig,
-    quickInsert: ({
-      formatMessage
-    }) => {
-      if (options && options.allowInsertion !== true) {
-        return [];
-      }
+const expandPlugin = (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()) || {};
+  return {
+    name: 'expand',
+    nodes() {
+      return [{
+        name: 'expand',
+        node: expand
+      }, {
+        name: 'nestedExpand',
+        node: nestedExpand
+      }];
+    },
+    pmPlugins() {
       return [{
-        id: 'expand',
-        title: formatMessage(messages.expand),
-        description: formatMessage(messages.expandDescription),
-        keywords: ['accordion', 'collapse'],
-        priority: 600,
-        icon: () => /*#__PURE__*/React.createElement(IconExpand, null),
-        action(insert, state) {
-          const node = createExpandNode(state);
-          const tr = insert(node);
-          return addAnalytics(state, tr, {
-            action: ACTION.INSERTED,
-            actionSubject: ACTION_SUBJECT.DOCUMENT,
-            actionSubjectId: node.type === state.schema.nodes.nestedExpand ? ACTION_SUBJECT_ID.NESTED_EXPAND : ACTION_SUBJECT_ID.EXPAND,
-            attributes: {
-              inputMethod: INPUT_METHOD.QUICK_INSERT
-            },
-            eventType: EVENT_TYPE.TRACK
-          });
+        name: 'expand',
+        plugin: ({
+          dispatch,
+          getIntl
+        }) => {
+          return createPlugin(dispatch, getIntl, options.appearance, options.useLongPressSelection, featureFlags);
         }
+      }, {
+        name: 'expandKeymap',
+        plugin: expandKeymap
       }];
+    },
+    pluginsOptions: {
+      floatingToolbar: getToolbarConfig,
+      quickInsert: ({
+        formatMessage
+      }) => {
+        if (options && options.allowInsertion !== true) {
+          return [];
+        }
+        return [{
+          id: 'expand',
+          title: formatMessage(messages.expand),
+          description: formatMessage(messages.expandDescription),
+          keywords: ['accordion', 'collapse'],
+          priority: 600,
+          icon: () => /*#__PURE__*/React.createElement(IconExpand, null),
+          action(insert, state) {
+            const node = createExpandNode(state);
+            const tr = insert(node);
+            return addAnalytics(state, tr, {
+              action: ACTION.INSERTED,
+              actionSubject: ACTION_SUBJECT.DOCUMENT,
+              actionSubjectId: node.type === state.schema.nodes.nestedExpand ? ACTION_SUBJECT_ID.NESTED_EXPAND : ACTION_SUBJECT_ID.EXPAND,
+              attributes: {
+                inputMethod: INPUT_METHOD.QUICK_INSERT
+              },
+              eventType: EVENT_TYPE.TRACK
+            });
+          }
+        }];
+      }
     }
-  }
-});
+  };
+};
 export default expandPlugin;
 export function isExpandInsertionEnabled({
   allowExpand

package/dist/es2019/plugins/expand/nodeviews/index.js

@@ -10,7 +10,6 @@ import { isEmptyNode } from '../../../utils';
 import { updateExpandTitle, toggleExpandExpanded, deleteExpandAtPos, setSelectionInsideExpand } from '../commands';
 import { expandClassNames } from '../ui/class-names';
 import { GapCursorSelection, Side } from '../../../plugins/selection/gap-cursor-selection';
-import { getFeatureFlags } from '../../feature-flags-context';
 import { closestElement } from '../../../utils/dom';
 import { RelativeSelectionPos } from '../../selection/types';
 import { setSelectionRelativeToNode } from '../../selection/commands';
@@ -50,7 +49,7 @@ const toDOM = (node, intl) => ['div', {
   'class': expandClassNames.content
 }, 0]];
 export class ExpandNodeView {
-  constructor(node, view, getPos, getIntl, isMobile) {
+  constructor(node, view, getPos, getIntl, isMobile, featureFlags) {
     _defineProperty(this, "allowInteractiveExpand", true);
     _defineProperty(this, "isMobile", false);
     _defineProperty(this, "focusTitle", () => {
@@ -77,11 +76,7 @@ export class ExpandNodeView {
       }
     });
     _defineProperty(this, "isAllowInteractiveExpandEnabled", () => {
-      const {
-        state
-      } = this.view;
-      const featureFlags = getFeatureFlags(state);
-      return featureFlags && !!featureFlags.interactiveExpand;
+      return this.featureFlags && !!this.featureFlags.interactiveExpand;
     });
     _defineProperty(this, "handleClick", event => {
       const target = event.target;
@@ -299,6 +294,7 @@ export class ExpandNodeView {
     this.dom = dom;
     this.contentDOM = contentDOM;
     this.isMobile = isMobile;
+    this.featureFlags = featureFlags;
     this.icon = this.dom.querySelector(`.${expandClassNames.icon}`);
     this.input = this.dom.querySelector(`.${expandClassNames.titleInput}`);
     this.titleContainer = this.dom.querySelector(`.${expandClassNames.titleContainer}`);
@@ -404,7 +400,8 @@ export class ExpandNodeView {
 }
 export default function ({
   getIntl,
-  isMobile
+  isMobile,
+  featureFlags
 }) {
-  return (node, view, getPos) => new ExpandNodeView(node, view, getPos, getIntl, isMobile);
+  return (node, view, getPos) => new ExpandNodeView(node, view, getPos, getIntl, isMobile, featureFlags);
 }

package/dist/es2019/plugins/expand/pm-plugins/main.js

@@ -10,7 +10,7 @@ export function containsClass(element, className) {
   var _element$classList;
   return Boolean(element === null || element === void 0 ? void 0 : (_element$classList = element.classList) === null || _element$classList === void 0 ? void 0 : _element$classList.contains(className));
 }
-export const createPlugin = (dispatch, getIntl, appearance = 'full-page', useLongPressSelection = false) => {
+export const createPlugin = (dispatch, getIntl, appearance = 'full-page', useLongPressSelection = false, featureFlags) => {
   const state = createPluginState(dispatch, {});
   const isMobile = appearance === 'mobile';
   return new SafePlugin({
@@ -20,11 +20,13 @@ export const createPlugin = (dispatch, getIntl, appearance = 'full-page', useLon
       nodeViews: {
         expand: ExpandNodeView({
           getIntl,
-          isMobile
+          isMobile,
+          featureFlags
         }),
         nestedExpand: ExpandNodeView({
           getIntl,
-          isMobile
+          isMobile,
+          featureFlags
         })
       },
       handleKeyDown(_view, event) {

package/dist/es2019/plugins/extension/extension-api.js

@@ -1,13 +1,13 @@
 import { validator } from '@atlaskit/adf-utils/validator';
 import { JSONTransformer } from '@atlaskit/editor-json-transformer';
 import { Fragment, Mark } from 'prosemirror-model';
-import { NodeSelection } from 'prosemirror-state';
+import { NodeSelection, Selection } from 'prosemirror-state';
 import { insertMacroFromMacroBrowser } from '../macro';
 import { pluginKey as macroPluginKey } from '../macro/plugin-key';
+import { nodeToJSON } from '../../utils';
 import { setEditingContextToContextPanel } from './commands';
-import { findNodePosWithLocalId, getSelectedExtension } from './utils';
+import { findNodePosWithLocalId, getDataConsumerMark, getNodeTypesReferenced, getSelectedExtension } from './utils';
 import { addAnalytics, ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '../analytics';
-import { getNodeTypesReferenced, getDataConsumerMark } from './utils';
 import { setTextSelection } from 'prosemirror-utils';
 export const getEditInLegacyMacroBrowser = ({
   view,
@@ -37,7 +37,18 @@ const extensionAPICallPayload = functionName => ({
   eventType: EVENT_TYPE.TRACK
 });
 export const createExtensionAPI = options => {
-  const validate = validator();
+  const {
+    editorView: {
+      state: {
+        schema
+      }
+    }
+  } = options;
+  const nodes = Object.keys(schema.nodes);
+  const marks = Object.keys(schema.marks);
+  const validate = validator(nodes, marks, {
+    allowPrivateAttributes: true
+  });
 
   /**
    * Finds the node and its position by `localId`. Throws if the node could not be found.
@@ -189,20 +200,20 @@ export const createExtensionAPI = options => {
         schema
       } = state;
       const changedValues = mutationCallback({
+        content: nodeToJSON(node).content,
         attrs: node.attrs,
         marks: node.marks.map(pmMark => ({
           type: pmMark.type.name,
           attrs: pmMark.attrs
         }))
       });
-      const {
-        parent
-      } = state.doc.resolve(pos);
       const ensureValidMark = mark => {
         if (typeof mark !== 'object' || Array.isArray(mark)) {
           throw new Error(`update(): Invalid mark given.`);
         }
-
+        const {
+          parent
+        } = state.doc.resolve(pos);
         // Ensure that the given mark is present in the schema
         const markType = schema.marks[mark.type];
         if (!markType) {
@@ -216,20 +227,27 @@ export const createExtensionAPI = options => {
           attrs: mark.attrs
         };
       };
-      const newMarks = (_changedValues$marks = changedValues.marks) === null || _changedValues$marks === void 0 ? void 0 : _changedValues$marks.map(ensureValidMark).map(({
+      const newMarks = changedValues.hasOwnProperty('marks') ? (_changedValues$marks = changedValues.marks) === null || _changedValues$marks === void 0 ? void 0 : _changedValues$marks.map(ensureValidMark).map(({
         mark,
         attrs
-      }) => mark.create(attrs));
+      }) => mark.create(attrs)) : node.marks;
+      const newContent = changedValues.hasOwnProperty('content') ? Fragment.fromJSON(schema, changedValues.content) : node.content;
+      const newAttrs = changedValues.hasOwnProperty('attrs') ? changedValues.attrs : node.attrs;
 
-      // Validate if the new attributes and marks result in a valid node and adf.
+      // Validate if the new attributes, content and marks result in a valid node and adf.
       try {
-        const newNode = node.type.createChecked(changedValues.attrs, node.content, newMarks);
+        const newNode = node.type.createChecked(newAttrs, newContent, newMarks);
         const newNodeAdf = new JSONTransformer().encodeNode(newNode);
         validate(newNodeAdf);
+        tr.replaceWith(pos, pos + node.nodeSize, newNode);
+
+        // Keep selection if content does not change
+        if (newContent === node.content) {
+          tr.setSelection(Selection.fromJSON(tr.doc, state.selection.toJSON()));
+        }
       } catch (err) {
         throw new Error(`update(): The given ADFEntity cannot be inserted in the current position.\n${err}`);
       }
-      tr.setNodeMarkup(pos, undefined, changedValues.attrs, newMarks);
 
       // Analytics - tracking the api call
       const apiCallPayload = extensionAPICallPayload('update');