@atlaskit/editor-core 181.0.1 → 182.0.1

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

@@ -1,38 +1,11 @@
 import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { getExtensionModuleNode } from '@atlaskit/editor-common/extensions';
 import { createSelectionClickHandler } from '../../selection/utils';
 import ExtensionNodeView from '../nodeviews/extension';
 import { updateState, clearEditingContext } from '../commands';
 import { getSelectedExtension, getSelectedDomElement } from '../utils';
 import { createPluginState, getPluginState, createCommand } from '../plugin-factory';
 import { pluginKey } from '../plugin-key';
-const maybeGetUpdateMethodFromExtensionProvider = async (view, extensionProvider) => {
-  const nodeWithPos = getSelectedExtension(view.state, true);
-  if (!nodeWithPos) {
-    throw new Error('There is no selection');
-  }
-  const {
-    extensionType,
-    extensionKey
-  } = nodeWithPos.node.attrs;
-  const extensionModuleNode = await getExtensionModuleNode(extensionProvider, extensionType, extensionKey);
-  const newNodeWithPos = getSelectedExtension(view.state, true);
-  if (newNodeWithPos && newNodeWithPos.node.attrs.extensionType === extensionType && newNodeWithPos.node.attrs.extensionKey === extensionKey && newNodeWithPos.pos === nodeWithPos.pos && extensionModuleNode) {
-    return extensionModuleNode.update;
-  }
-};
-export const updateEditButton = async (view, extensionProvider) => {
-  try {
-    const updateMethod = await maybeGetUpdateMethodFromExtensionProvider(view, extensionProvider);
-    updateState({
-      showEditButton: !!updateMethod,
-      updateExtension: updateMethod && Promise.resolve(updateMethod) || undefined
-    })(view.state, view.dispatch);
-    return updateMethod;
-  } catch {
-    // this exception is not important for this case, fail silently
-  }
-};
+import { updateEditButton } from './utils';
 const shouldShowEditButton = (extensionHandler, extensionProvider) => {
   const usesLegacyMacroBrowser = !extensionHandler && !extensionProvider || typeof extensionHandler === 'function';
   const usesModernUpdateMethod = typeof extensionHandler === 'object' && typeof extensionHandler.update === 'function';
@@ -83,6 +56,75 @@ export const createContextIdentifierProviderHandler = view => async (name, provi
     }
   }
 };
+export const handleUpdate = ({
+  view,
+  prevState,
+  domAtPos,
+  extensionHandlers
+}) => {
+  const {
+    state,
+    dispatch
+  } = view;
+  const {
+    element,
+    localId,
+    extensionProvider,
+    showContextPanel,
+    showEditButton
+  } = getPluginState(state);
+
+  // This fetches the selected extension node, either by keyboard selection or click for all types of extensions
+  const selectedExtension = getSelectedExtension(state, true);
+  if (!selectedExtension) {
+    if (showContextPanel) {
+      clearEditingContext(state, dispatch);
+    }
+    return;
+  }
+  const {
+    node
+  } = selectedExtension;
+  const newElement = getSelectedDomElement(state.schema, domAtPos, selectedExtension);
+
+  // In some cases, showEditButton can be stale and the edit button doesn't show - @see ED-15285
+  // To be safe, we update the showEditButton state here
+  const shouldUpdateEditButton = !showEditButton && extensionProvider && element === newElement && !getSelectedExtension(prevState, true);
+  const isNewNodeSelected = node.attrs.localId ? localId !== node.attrs.localId :
+  // This is the current assumption and it's wrong but we are keeping it
+  // as fallback in case we need to turn off `allowLocalIdGeneration`
+  element !== newElement;
+  if (isNewNodeSelected || shouldUpdateEditButton) {
+    if (showContextPanel) {
+      clearEditingContext(state, dispatch);
+      return;
+    }
+    const {
+      extensionType
+    } = node.attrs;
+    const extensionHandler = extensionHandlers[extensionType];
+
+    // showEditButton might change async based on results from extension providers
+    const showEditButton = shouldShowEditButton(extensionHandler, extensionProvider);
+    const updateExtension = getUpdateExtensionPromise(view, extensionHandler, extensionProvider).catch(() => {
+      // do nothing;
+    });
+    updateState({
+      localId: node.attrs.localId,
+      showContextPanel: false,
+      element: newElement,
+      showEditButton,
+      updateExtension
+    })(state, dispatch);
+  }
+  // New DOM element doesn't necessarily mean it's a new Node
+  else if (element !== newElement) {
+    updateState({
+      element: newElement
+    })(state, dispatch);
+  }
+  return true;
+};
 const createPlugin = (dispatch, providerFactory, extensionHandlers, portalProviderAPI, eventDispatcher, useLongPressSelection = false, options = {}) => {
   const state = createPluginState(dispatch, {
     showEditButton: false,
@@ -100,74 +142,13 @@ const createPlugin = (dispatch, providerFactory, extensionHandlers, portalProvid
       providerFactory.subscribe('extensionProvider', extensionProviderHandler);
       providerFactory.subscribe('contextIdentificationProvider', contextIdentificationProviderHandler);
       return {
-        update: view => {
-          const {
-            state,
-            dispatch
-          } = view;
-          const {
-            element,
-            localId,
-            extensionProvider,
-            showContextPanel
-          } = getPluginState(state);
-
-          // This fetches the selected extension node, either by keyboard selection or click for all types of extensions
-          const selectedExtension = getSelectedExtension(state, true);
-          if (!selectedExtension) {
-            if (showContextPanel) {
-              clearEditingContext(state, dispatch);
-            }
-
-            // if an extension is no longer selected, but the plugin has cached the previous selected extension id/ref
-            // then this should clear those values so that if an exention is selected again, then this sees it as a change
-            // and updates the state correctly.
-            if (!!localId || !!element) {
-              updateState({
-                localId: undefined,
-                element: undefined
-              })(state, dispatch);
-            }
-            return;
-          }
-          const {
-            node
-          } = selectedExtension;
-          const newElement = getSelectedDomElement(state.schema, domAtPos, selectedExtension);
-
-          // New node is selection
-          if (node.attrs.localId ? localId !== node.attrs.localId :
-          // This is the current assumption and it's wrong but we are keeping it
-          // as fallback in case we need to turn off `allowLocalIdGeneration`
-          element !== newElement) {
-            if (showContextPanel) {
-              clearEditingContext(state, dispatch);
-            }
-            const {
-              extensionType
-            } = node.attrs;
-            const extensionHandler = extensionHandlers[extensionType];
-
-            // showEditButton might change async based on results from extension providers
-            const showEditButton = shouldShowEditButton(extensionHandler, extensionProvider);
-            const updateExtension = getUpdateExtensionPromise(view, extensionHandler, extensionProvider).catch(() => {
-              // do nothing;
-            });
-            updateState({
-              localId: node.attrs.localId,
-              showContextPanel: false,
-              element: newElement,
-              showEditButton,
-              updateExtension
-            })(state, dispatch);
-          }
-          // New DOM element doesn't necessarily mean it's a new Node
-          else if (element !== newElement) {
-            updateState({
-              element: newElement
-            })(state, dispatch);
-          }
-          return true;
+        update: (view, prevState) => {
+          handleUpdate({
+            view,
+            prevState,
+            domAtPos,
+            extensionHandlers
+          });
         },
         destroy: () => {
           providerFactory.unsubscribe('extensionProvider', extensionProviderHandler);

package/dist/es2019/plugins/extension/pm-plugins/utils.js

@@ -0,0 +1,30 @@
+import { getExtensionModuleNode } from '@atlaskit/editor-common/extensions';
+import { updateState } from '../commands';
+import { getSelectedExtension } from '../utils';
+const maybeGetUpdateMethodFromExtensionProvider = async (view, extensionProvider) => {
+  const nodeWithPos = getSelectedExtension(view.state, true);
+  if (!nodeWithPos) {
+    throw new Error('There is no selection');
+  }
+  const {
+    extensionType,
+    extensionKey
+  } = nodeWithPos.node.attrs;
+  const extensionModuleNode = await getExtensionModuleNode(extensionProvider, extensionType, extensionKey);
+  const newNodeWithPos = getSelectedExtension(view.state, true);
+  if (newNodeWithPos && newNodeWithPos.node.attrs.extensionType === extensionType && newNodeWithPos.node.attrs.extensionKey === extensionKey && newNodeWithPos.pos === nodeWithPos.pos && extensionModuleNode) {
+    return extensionModuleNode.update;
+  }
+};
+export const updateEditButton = async (view, extensionProvider) => {
+  try {
+    const updateMethod = await maybeGetUpdateMethodFromExtensionProvider(view, extensionProvider);
+    updateState({
+      showEditButton: !!updateMethod,
+      updateExtension: updateMethod && Promise.resolve(updateMethod) || undefined
+    })(view.state, view.dispatch);
+    return updateMethod;
+  } catch {
+    // this exception is not important for this case, fail silently
+  }
+};

package/dist/es2019/plugins/feature-flags-context/get-enabled-feature-flag-keys.js

@@ -1,8 +1 @@
-/**
- * Transforms FeatureFlags to a type safe string array of the enabled feature flags.
- *
- * Useful for analytics and analysis purposes.
- */
-export function getEnabledFeatureFlagKeys(featureFlags) {
-  return Object.keys(featureFlags).filter(key => featureFlags[key] === true);
-}
+export { getEnabledFeatureFlagKeys } from '@atlaskit/editor-common/normalize-feature-flags';

package/dist/es2019/plugins/find-replace/FindReplaceToolbarButtonWithState.js

@@ -5,7 +5,6 @@ import { cancelSearchWithAnalytics, replaceWithAnalytics, replaceAllWithAnalytic
 import { blur, toggleMatchCase } from './commands';
 import FindReplaceToolbarButton from './ui/FindReplaceToolbarButton';
 import { TRIGGER_METHOD } from '../analytics';
-import { getFeatureFlags } from '../feature-flags-context';
 const FindReplaceToolbarButtonWithState = props => {
   const {
     popupsBoundariesElement,
@@ -14,7 +13,8 @@ const FindReplaceToolbarButtonWithState = props => {
     isToolbarReducedSpacing,
     editorView,
     containerElement,
-    dispatchAnalyticsEvent
+    dispatchAnalyticsEvent,
+    featureFlags
   } = props;
   if (!editorView) {
     return null;
@@ -94,7 +94,7 @@ const FindReplaceToolbarButtonWithState = props => {
   };
   const {
     findReplaceMatchCase
-  } = getFeatureFlags(editorView.state);
+  } = featureFlags;
   return /*#__PURE__*/React.createElement(WithPluginState, {
     debounce: false,
     plugins: {

package/dist/es2019/plugins/find-replace/index.js

@@ -2,7 +2,9 @@ import React from 'react';
 import { createPlugin } from './plugin';
 import keymapPlugin from './keymap';
 import FindReplaceToolbarButtonWithState from './FindReplaceToolbarButtonWithState';
-export const findReplacePlugin = props => {
+export const findReplacePlugin = (props, 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: 'findReplace',
     pmPlugins() {
@@ -36,7 +38,8 @@ export const findReplacePlugin = props => {
           editorView: editorView,
           containerElement: containerElement,
           dispatchAnalyticsEvent: dispatchAnalyticsEvent,
-          takeFullWidth: props.takeFullWidth
+          takeFullWidth: props.takeFullWidth,
+          featureFlags: featureFlags
         });
       }
     }

package/dist/es2019/plugins/floating-toolbar/index.js

@@ -19,7 +19,6 @@ import { ConfirmationModal } from './ui/ConfirmationModal';
 import { ToolbarLoader } from './ui/ToolbarLoader';
 import { findNode } from './utils';
 import { ErrorBoundary } from '../../ui/ErrorBoundary';
-import { getFeatureFlags } from '../feature-flags-context';
 import { processCopyButtonItems } from '../copy-button/toolbar';
 import forceFocusPlugin from './pm-plugins/force-focus';
 export const getRelevantConfig = (selection, configs) => {
@@ -113,156 +112,167 @@ const getDomRefFromSelection = (view, dispatchAnalyticsEvent) => {
 function filterUndefined(x) {
   return !!x;
 }
-const floatingToolbarPlugin = () => ({
-  name: 'floatingToolbar',
-  pmPlugins(floatingToolbarHandlers = []) {
-    return [{
-      // Should be after all toolbar plugins
-      name: 'floatingToolbar',
-      plugin: ({
-        dispatch,
-        providerFactory,
-        getIntl
-      }) => floatingToolbarPluginFactory({
-        floatingToolbarHandlers,
-        dispatch,
-        providerFactory,
-        getIntl
-      })
-    }, {
-      name: 'floatingToolbarData',
-      plugin: ({
-        dispatch
-      }) => floatingToolbarDataPluginFactory(dispatch)
-    }, {
-      name: 'forceFocus',
-      plugin: () => forceFocusPlugin()
-    }];
-  },
-  contentComponent({
-    popupsMountPoint,
-    popupsBoundariesElement,
-    popupsScrollableElement,
-    editorView,
-    providerFactory,
-    dispatchAnalyticsEvent
-  }) {
-    return /*#__PURE__*/React.createElement(WithPluginState, {
-      plugins: {
-        floatingToolbarState: pluginKey,
-        floatingToolbarData: dataPluginKey,
-        editorDisabledPlugin: editorDisabledPluginKey,
-        extensionsState: extensionsPluginKey
-      },
-      render: ({
-        editorDisabledPlugin,
-        floatingToolbarState,
-        floatingToolbarData,
-        extensionsState
-      }) => {
-        var _configWithNodeInfo$c, _configWithNodeInfo$c2;
-        const configWithNodeInfo = floatingToolbarState === null || floatingToolbarState === void 0 ? void 0 : floatingToolbarState.getConfigWithNodeInfo(editorView.state);
-        if (!configWithNodeInfo || !configWithNodeInfo.config || typeof ((_configWithNodeInfo$c = configWithNodeInfo.config) === null || _configWithNodeInfo$c === void 0 ? void 0 : _configWithNodeInfo$c.visible) !== 'undefined' && !((_configWithNodeInfo$c2 = configWithNodeInfo.config) !== null && _configWithNodeInfo$c2 !== void 0 && _configWithNodeInfo$c2.visible)) {
-          return null;
-        }
-        const {
-          config,
-          node
-        } = configWithNodeInfo;
-        const {
-          title,
-          getDomRef = getDomRefFromSelection,
-          items,
-          align = 'center',
-          className = '',
-          height,
-          width,
-          zIndex,
-          offset = [0, 12],
-          forcePlacement,
-          preventPopupOverflow,
-          onPositionCalculated,
-          focusTrap
-        } = config;
-        const targetRef = getDomRef(editorView, dispatchAnalyticsEvent);
-        if (!targetRef || editorDisabledPlugin && editorDisabledPlugin.editorDisabled) {
-          return null;
-        }
-        let customPositionCalculation;
-        const toolbarItems = processCopyButtonItems(editorView.state)(Array.isArray(items) ? items : items(node));
-        if (onPositionCalculated) {
-          customPositionCalculation = nextPos => {
-            return onPositionCalculated(editorView, nextPos);
-          };
-        }
-        const dispatchCommand = fn => fn && fn(editorView.state, editorView.dispatch, editorView);
+const floatingToolbarPlugin = (_, 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: 'floatingToolbar',
+    pmPlugins(floatingToolbarHandlers = []) {
+      return [{
+        // Should be after all toolbar plugins
+        name: 'floatingToolbar',
+        plugin: ({
+          dispatch,
+          providerFactory,
+          getIntl
+        }) => floatingToolbarPluginFactory({
+          floatingToolbarHandlers,
+          dispatch,
+          providerFactory,
+          getIntl
+        })
+      }, {
+        name: 'floatingToolbarData',
+        plugin: ({
+          dispatch
+        }) => floatingToolbarDataPluginFactory(dispatch)
+      }, {
+        name: 'forceFocus',
+        plugin: () => forceFocusPlugin()
+      }];
+    },
+    contentComponent({
+      popupsMountPoint,
+      popupsBoundariesElement,
+      popupsScrollableElement,
+      editorView,
+      providerFactory,
+      dispatchAnalyticsEvent
+    }) {
+      return /*#__PURE__*/React.createElement(WithPluginState, {
+        plugins: {
+          floatingToolbarState: pluginKey,
+          floatingToolbarData: dataPluginKey,
+          editorDisabledPlugin: editorDisabledPluginKey,
+          extensionsState: extensionsPluginKey
+        },
+        render: ({
+          editorDisabledPlugin,
+          floatingToolbarState,
+          floatingToolbarData,
+          extensionsState
+        }) => {
+          var _configWithNodeInfo$c, _configWithNodeInfo$c2;
+          const configWithNodeInfo = floatingToolbarState === null || floatingToolbarState === void 0 ? void 0 : floatingToolbarState.getConfigWithNodeInfo(editorView.state);
+          if (!configWithNodeInfo || !configWithNodeInfo.config || typeof ((_configWithNodeInfo$c = configWithNodeInfo.config) === null || _configWithNodeInfo$c === void 0 ? void 0 : _configWithNodeInfo$c.visible) !== 'undefined' && !((_configWithNodeInfo$c2 = configWithNodeInfo.config) !== null && _configWithNodeInfo$c2 !== void 0 && _configWithNodeInfo$c2.visible)) {
+            return null;
+          }
+          const {
+            config,
+            node
+          } = configWithNodeInfo;
+          const {
+            title,
+            getDomRef = getDomRefFromSelection,
+            items,
+            align = 'center',
+            className = '',
+            height,
+            width,
+            zIndex,
+            offset = [0, 12],
+            forcePlacement,
+            preventPopupOverflow,
+            onPositionCalculated,
+            focusTrap
+          } = config;
+          const targetRef = getDomRef(editorView, dispatchAnalyticsEvent);
+          if (!targetRef || editorDisabledPlugin && editorDisabledPlugin.editorDisabled) {
+            return null;
+          }
+          let customPositionCalculation;
+          const toolbarItems = processCopyButtonItems(editorView.state)(Array.isArray(items) ? items : items(node));
+          if (onPositionCalculated) {
+            customPositionCalculation = nextPos => {
+              return onPositionCalculated(editorView, nextPos);
+            };
+          }
+          const dispatchCommand = fn => fn && fn(editorView.state, editorView.dispatch, editorView);
 
-        // Confirm dialog
-        const {
-          confirmDialogForItem
-        } = floatingToolbarData || {};
-        const confirmButtonItem = confirmDialogForItem ? toolbarItems[confirmDialogForItem] : undefined;
-        const scrollable = getFeatureFlags(editorView.state).floatingToolbarCopyButton && config.scrollable;
-        const confirmDialogOptions = typeof (confirmButtonItem === null || confirmButtonItem === void 0 ? void 0 : confirmButtonItem.confirmDialog) === 'function' ? confirmButtonItem === null || confirmButtonItem === void 0 ? void 0 : confirmButtonItem.confirmDialog() : confirmButtonItem === null || confirmButtonItem === void 0 ? void 0 : confirmButtonItem.confirmDialog;
-        return /*#__PURE__*/React.createElement(ErrorBoundary, {
-          component: ACTION_SUBJECT.FLOATING_TOOLBAR_PLUGIN,
-          componentId: camelCase(title),
-          dispatchAnalyticsEvent: dispatchAnalyticsEvent,
-          fallbackComponent: null
-        }, /*#__PURE__*/React.createElement(Popup, {
-          ariaLabel: title,
-          offset: offset,
-          target: targetRef,
-          alignY: "bottom",
-          forcePlacement: forcePlacement,
-          fitHeight: height,
-          fitWidth: width,
-          alignX: align,
-          stick: true,
-          zIndex: zIndex,
-          mountTo: popupsMountPoint,
-          boundariesElement: popupsBoundariesElement,
-          scrollableElement: popupsScrollableElement,
-          onPositionCalculated: customPositionCalculation,
-          style: scrollable ? {
-            maxWidth: '100%'
-          } : {},
-          focusTrap: focusTrap,
-          preventOverflow: preventPopupOverflow
-        }, /*#__PURE__*/React.createElement(ToolbarLoader, {
-          target: targetRef,
-          items: toolbarItems,
-          node: node,
-          dispatchCommand: dispatchCommand,
-          editorView: editorView,
-          className: className,
-          focusEditor: () => editorView.focus(),
-          providerFactory: providerFactory,
-          popupsMountPoint: popupsMountPoint,
-          popupsBoundariesElement: popupsBoundariesElement,
-          popupsScrollableElement: popupsScrollableElement,
-          dispatchAnalyticsEvent: dispatchAnalyticsEvent,
-          extensionsProvider: extensionsState === null || extensionsState === void 0 ? void 0 : extensionsState.extensionProvider,
-          scrollable: scrollable
-        })), /*#__PURE__*/React.createElement(ConfirmationModal, {
-          options: confirmDialogOptions,
-          onConfirm: (isChecked = false) => {
-            if (!!confirmDialogOptions.onConfirm) {
-              dispatchCommand(confirmDialogOptions.onConfirm(isChecked));
-            } else {
-              dispatchCommand(confirmButtonItem.onClick);
+          // Confirm dialog
+          const {
+            confirmDialogForItem
+          } = floatingToolbarData || {};
+          const confirmButtonItem = confirmDialogForItem ? toolbarItems[confirmDialogForItem] : undefined;
+          const scrollable = featureFlags.floatingToolbarCopyButton && config.scrollable;
+          const confirmDialogOptions = typeof (confirmButtonItem === null || confirmButtonItem === void 0 ? void 0 : confirmButtonItem.confirmDialog) === 'function' ? confirmButtonItem === null || confirmButtonItem === void 0 ? void 0 : confirmButtonItem.confirmDialog() : confirmButtonItem === null || confirmButtonItem === void 0 ? void 0 : confirmButtonItem.confirmDialog;
+          return /*#__PURE__*/React.createElement(ErrorBoundary, {
+            component: ACTION_SUBJECT.FLOATING_TOOLBAR_PLUGIN,
+            componentId: camelCase(title),
+            dispatchAnalyticsEvent: dispatchAnalyticsEvent,
+            fallbackComponent: null
+          }, /*#__PURE__*/React.createElement(Popup, {
+            ariaLabel: title,
+            offset: offset,
+            target: targetRef,
+            alignY: "bottom",
+            forcePlacement: forcePlacement,
+            fitHeight: height,
+            fitWidth: width,
+            alignX: align,
+            stick: true,
+            zIndex: zIndex,
+            mountTo: popupsMountPoint,
+            boundariesElement: popupsBoundariesElement,
+            scrollableElement: popupsScrollableElement,
+            onPositionCalculated: customPositionCalculation,
+            style: scrollable ? {
+              maxWidth: '100%'
+            } : {},
+            focusTrap: focusTrap,
+            preventOverflow: preventPopupOverflow
+          }, /*#__PURE__*/React.createElement(ToolbarLoader, {
+            target: targetRef,
+            items: toolbarItems,
+            node: node,
+            dispatchCommand: dispatchCommand,
+            editorView: editorView,
+            className: className,
+            focusEditor: () => editorView.focus(),
+            providerFactory: providerFactory,
+            popupsMountPoint: popupsMountPoint,
+            popupsBoundariesElement: popupsBoundariesElement,
+            popupsScrollableElement: popupsScrollableElement,
+            dispatchAnalyticsEvent: dispatchAnalyticsEvent,
+            extensionsProvider: extensionsState === null || extensionsState === void 0 ? void 0 : extensionsState.extensionProvider,
+            scrollable: scrollable,
+            featureFlags: featureFlags
+          })), /*#__PURE__*/React.createElement(ConfirmationModal, {
+            testId: "ak-floating-toolbar-confirmation-modal",
+            options: confirmDialogOptions,
+            onConfirm: (isChecked = false) => {
+              if (!!confirmDialogOptions.onConfirm) {
+                dispatchCommand(confirmDialogOptions.onConfirm(isChecked));
+              } else {
+                dispatchCommand(confirmButtonItem.onClick);
+              }
+            },
+            onClose: () => {
+              dispatchCommand(hideConfirmDialog());
+              // Need to set focus to Editor here,
+              // As when the Confirmation dialog pop up, and user interacts with the dialog, Editor loses focus.
+              // So when Confirmation dialog is closed, Editor does not have the focus, then cursor goes to the position 1 of the doc,
+              // instead of the cursor position before the dialog pop up.
+              if (!editorView.hasFocus()) {
+                editorView.focus();
+              }
             }
-            dispatchCommand(hideConfirmDialog());
-          } // When closed without clicking OK or cancel buttons
-          ,
-          onClose: () => {
-            dispatchCommand(hideConfirmDialog());
-          }
-        }));
-      }
-    });
-  }
-});
+          }));
+        }
+      });
+    }
+  };
+};
 export default floatingToolbarPlugin;
 
 /**

package/dist/es2019/plugins/floating-toolbar/ui/CheckboxModal.js

@@ -62,7 +62,10 @@ export const CheckboxModal = props => {
     testId: testId ? `${testId}-cancel-button` : undefined
   }, cancelButtonLabel), /*#__PURE__*/React.createElement(Button, {
     appearance: "warning",
-    onClick: () => onConfirm(isChecked),
+    onClick: () => {
+      onConfirm(isChecked);
+      onClose();
+    },
     testId: testId ? `${testId}-confirm-button` : undefined
   }, okButtonLabel)));
 };