revert: undo context-menu paste fix attempts

Reverts the paste whitespace/selection fixes (3a9a980, 1912016,
bafd1ce). The underlying issue — ProseMirror stripping trailing
whitespace during paste into run-wrapped content — needs deeper
investigation. Tracked separately.

Author: caio-pizzol

packages/super-editor/src/components/context-menu/ContextMenu.vue

@@ -296,14 +296,21 @@ const handleRightClick = async (event) => {
 
   event.preventDefault();
 
-  // Update cursor position to the right-click location before opening context menu.
-  // When the user has a range selection, keep it — coordinate-based hit testing
-  // in presentation mode can misreport whether the click is inside the selection,
-  // which would collapse it unexpectedly.
+  // Update cursor position to the right-click location before opening context menu,
+  // unless the click lands inside an active selection (keep selection intact).
   const editorState = props.editor?.state;
   const hasRangeSelection = editorState?.selection?.from !== editorState?.selection?.to;
+  let isClickInsideSelection = false;
 
-  if (!hasRangeSelection) {
+  if (hasRangeSelection && Number.isFinite(event.clientX) && Number.isFinite(event.clientY)) {
+    const hit = props.editor?.posAtCoords?.({ left: event.clientX, top: event.clientY });
+    if (typeof hit?.pos === 'number') {
+      const { from, to } = editorState.selection;
+      isClickInsideSelection = hit.pos >= from && hit.pos <= to;
+    }
+  }
+
+  if (!isClickInsideSelection) {
     moveCursorToMouseEvent(event, props.editor);
   }
 

packages/super-editor/src/components/context-menu/menuItems.js

@@ -300,14 +300,19 @@ export function getItems(context, customItems = [], includeDefaultItems = true)
           label: TEXTS.paste,
           icon: ICONS.paste,
           isDefault: true,
-          action: async (editor, context) => {
+          action: async (editor) => {
             const { view } = editor ?? {};
             if (!view) return;
-            // Use the selection captured when the context menu opened — the
-            // right-click handler may have collapsed a range selection via
-            // moveCursorToMouseEvent before this action runs.
-            const savedFrom = context?.selectionStart ?? view.state.selection.from;
-            const savedTo = context?.selectionEnd ?? view.state.selection.to;
+            // Save the current selection before focusing. When the context menu
+            // is open, its hidden search input holds focus, so the PM editor's
+            // contenteditable is blurred. A raw `view.dom.focus()` would restart
+            // ProseMirror's DOMObserver which reads the stale browser selection
+            // (collapsed at the document start) and overwrites the PM state.
+            // Using `view.focus()` (ProseMirror-aware) prevents this by writing
+            // the PM selection to the DOM before restarting the observer. We also
+            // save/restore as a safety net against async drift during clipboard reads.
+            const savedFrom = view.state.selection.from;
+            const savedTo = view.state.selection.to;
             view.focus();
             const { html, text } = await readClipboardRaw();
             // Restore selection after the async gap — ProseMirror's DOMObserver
@@ -323,20 +328,22 @@ export function getItems(context, customItems = [], includeDefaultItems = true)
                 view.dispatch(tr.setSelection(SelectionType.create(doc, safeFrom, safeTo)));
               }
             }
-            // When plain text is available, prefer view.pasteText — it preserves
-            // whitespace correctly. Chromium wraps writeText() output in HTML,
-            // which routes through handleHtmlPaste and strips leading/trailing spaces.
-            // Still run handleClipboardPaste for URL detection (passes empty html
-            // so it hits the 'plain-text' branch).
-            if (text) {
-              const urlHandled = handleClipboardPaste({ editor, view }, '', text);
-              if (!urlHandled && typeof view.pasteText === 'function') {
-                view.pasteText(text, createPasteEventShim({ html: '', text }));
+            const handled = handleClipboardPaste({ editor, view }, html, text);
+            if (!handled) {
+              const pasteEvent = createPasteEventShim({ html, text });
+
+              if (html && typeof view.pasteHTML === 'function') {
+                view.pasteHTML(html, pasteEvent);
+                return;
+              }
+
+              if (text && typeof view.pasteText === 'function') {
+                view.pasteText(text, pasteEvent);
+                return;
               }
-            } else if (html) {
-              const handled = handleClipboardPaste({ editor, view }, html, '');
-              if (!handled && typeof view.pasteHTML === 'function') {
-                view.pasteHTML(html, createPasteEventShim({ html, text: '' }));
+
+              if (text && editor.commands?.insertContent) {
+                editor.commands.insertContent(text, { contentType: 'text' });
               }
             }
           },

packages/super-editor/src/components/context-menu/tests/ContextMenu.test.js

@@ -294,10 +294,7 @@ describe('ContextMenu.vue', () => {
       expect(moveCursorToMouseEvent).not.toHaveBeenCalled();
     });
 
-    it('should not move cursor when right-click happens outside a range selection', async () => {
-      // When a range selection exists, the context menu preserves it — coordinate-based
-      // hit testing in presentation mode can misreport whether the click is inside the
-      // selection, which would collapse it unexpectedly.
+    it('should move cursor when right-click happens outside the active selection', async () => {
       mount(ContextMenu, { props: mockProps });
 
       const { moveCursorToMouseEvent } = await import('../../cursor-helpers.js');
@@ -316,7 +313,7 @@ describe('ContextMenu.vue', () => {
 
       await contextMenuHandler(rightClickEvent);
 
-      expect(moveCursorToMouseEvent).not.toHaveBeenCalled();
+      expect(moveCursorToMouseEvent).toHaveBeenCalledWith(rightClickEvent, mockEditor);
     });
 
     it('should allow native context menu when modifier is pressed', async () => {

packages/super-editor/src/components/context-menu/tests/menuItems.test.js

@@ -567,16 +567,12 @@ describe('menuItems.js', () => {
   });
 
   describe('getItems - paste action behavior', () => {
-    it('should prefer pasteText over pasteHTML when both html and text are available', async () => {
-      // When plain text is available, the paste action prefers view.pasteText
-      // because Chromium wraps writeText() output in HTML, which routes through
-      // handleHtmlPaste and strips leading/trailing spaces.
+    it('should not force plain-text insert when HTML paste is unhandled', async () => {
       const insertContent = vi.fn();
       mockEditor = createMockEditor({
         commands: { insertContent },
       });
       mockEditor.view.dom.focus = vi.fn();
-      mockEditor.view.pasteText = vi.fn();
       mockEditor.view.pasteHTML = vi.fn();
       mockContext = createMockContext({
         editor: mockEditor,
@@ -597,14 +593,12 @@ describe('menuItems.js', () => {
       expect(pasteAction).toBeTypeOf('function');
       await pasteAction(mockEditor);
 
-      // Passes empty html to handleClipboardPaste for URL detection only
       expect(clipboardMocks.handleClipboardPaste).toHaveBeenCalledWith(
         { editor: mockEditor, view: mockEditor.view },
-        '',
+        '<p>word html</p>',
         'word html',
       );
-      expect(mockEditor.view.pasteText).toHaveBeenCalledWith('word html', expect.any(Object));
-      expect(mockEditor.view.pasteHTML).not.toHaveBeenCalled();
+      expect(mockEditor.view.pasteHTML).toHaveBeenCalledWith('<p>word html</p>', expect.any(Object));
       expect(insertContent).not.toHaveBeenCalled();
     });
 
@@ -637,15 +631,11 @@ describe('menuItems.js', () => {
       expect(insertContent).not.toHaveBeenCalled();
     });
 
-    it('should not paste when view has no pasteText and handleClipboardPaste returns false', async () => {
-      // When pasteText is unavailable and URL detection returns false,
-      // the text branch has no further action. The code does not fall
-      // back to insertContent for the text branch.
+    it('should fall back to insertContent when view has no pasteHTML or pasteText', async () => {
       const insertContent = vi.fn();
       mockEditor = createMockEditor({
         commands: { insertContent },
       });
-      mockEditor.view.dom.focus = vi.fn();
       // No pasteHTML or pasteText on view
       delete mockEditor.view.pasteHTML;
       delete mockEditor.view.pasteText;
@@ -667,13 +657,7 @@ describe('menuItems.js', () => {
 
       await pasteAction(mockEditor);
 
-      expect(clipboardMocks.handleClipboardPaste).toHaveBeenCalledWith(
-        { editor: mockEditor, view: mockEditor.view },
-        '',
-        'fallback text',
-      );
-      // No pasteText available, URL detection returned false — nothing else happens
-      expect(insertContent).not.toHaveBeenCalled();
+      expect(insertContent).toHaveBeenCalledWith('fallback text', { contentType: 'text' });
     });
   });
 

packages/super-editor/src/core/InputRule.js

@@ -348,7 +348,7 @@ export function handleHtmlPaste(html, editor, source) {
     cleanedHtml.dataset.superdocImport = 'true';
   }
 
-  let doc = PMDOMParser.fromSchema(editor.schema).parse(cleanedHtml, { preserveWhitespace: true });
+  let doc = PMDOMParser.fromSchema(editor.schema).parse(cleanedHtml);
   doc = mergeAdjacentTableFragments(doc);
 
   doc = wrapTextsInRuns(doc);