feat(Math): parse TeX formulas when pasting from code editor and paste them as math block (#888)

Author: ReFFaT

src/extensions/additional/Math/Math.test.ts

@@ -5,6 +5,7 @@ import {ExtensionsManager} from '../../../core';
 import {BaseNode, BaseSchemaSpecs} from '../../base/specs';
 
 import {MathNode, MathSpecs} from './MathSpecs';
+import {isLatexMode, parseLatexFormulas} from './utils';
 
 const {
     schema,
@@ -47,3 +48,46 @@ describe('Math extension', () => {
         same(`$$${formula}$$\n\n`, doc(mathB(formula)));
     });
 });
+
+describe('latex-paste-plugin utilities', () => {
+    describe('isLatexMode', () => {
+        it('should return true for tex/latex modes', () => {
+            expect(isLatexMode('tex')).toBe(true);
+            expect(isLatexMode('latex')).toBe(true);
+            expect(isLatexMode('bibtex')).toBe(true);
+        });
+
+        it('should return false for non-latex modes', () => {
+            expect(isLatexMode('javascript')).toBe(false);
+            expect(isLatexMode('python')).toBe(false);
+            expect(isLatexMode(undefined)).toBe(false);
+        });
+    });
+
+    describe('parseLatexFormulas', () => {
+        it('should split formulas by double newlines', () => {
+            const input = 'E = mc^2\n\ne^{i\\pi} + 1 = 0';
+            const result = parseLatexFormulas(input);
+            expect(result).toEqual(['E = mc^2', 'e^{i\\pi} + 1 = 0']);
+        });
+
+        it('should preserve comment lines starting with %', () => {
+            const input = `% Einstein equation
+E = mc^2
+
+% Euler formula
+e^{i\\pi} + 1 = 0`;
+            const result = parseLatexFormulas(input);
+            expect(result).toEqual([
+                '% Einstein equation\nE = mc^2',
+                '% Euler formula\ne^{i\\pi} + 1 = 0',
+            ]);
+        });
+
+        it('should return comments as formulas', () => {
+            const input = '% Comment 1\n% Comment 2';
+            const result = parseLatexFormulas(input);
+            expect(result).toEqual(['% Comment 1\n% Comment 2']);
+        });
+    });
+});

src/extensions/additional/Math/const.ts

@@ -1,2 +1,13 @@
 export * from './MathSpecs/const';
 export {mathBType, mathIType} from './MathSpecs';
+
+export const LATEX_MODES = new Set([
+    'tex',
+    'latex',
+    'bibtex',
+    'doctex',
+    'latex-expl3',
+    'pweave',
+    'jlweave',
+    'rsweave',
+]);

src/extensions/additional/Math/index.ts

@@ -14,12 +14,14 @@ import {
     removeEmptyMathInlineIfCursorIsAtBeginning,
 } from './commands';
 import {mathBType, mathIType} from './const';
+import {latexPastePlugin} from './latex-paste-plugin';
 import {type MathNodeViewOptions, mathViewAndEditPlugin} from './view-and-edit';
 
 import './index.scss';
 
 export {MathNode, mathBType, mathIType} from './MathSpecs';
 export {MathBlockNodeView, MathInlineNodeView} from './view-and-edit';
+export {isLatexMode, parseLatexFormulas} from './utils';
 
 const mathIAction = 'addMathInline';
 const mathBAction = 'toMathBlock';
@@ -45,6 +47,7 @@ export const Math: ExtensionAuto<MathOptions> = (builder, opts) => {
     }));
 
     builder
+        .addPlugin(latexPastePlugin, builder.Priority.VeryHigh)
         .addPlugin(() =>
             mathViewAndEditPlugin({
                 ...opts,

src/extensions/additional/Math/latex-paste-plugin.ts

@@ -0,0 +1,58 @@
+import {Plugin} from 'prosemirror-state';
+
+import {getLoggerFromState} from '#core';
+import {Fragment} from '#pm/model';
+
+import {MathNode} from './const';
+import {getLatexData, parseLatexFormulas} from './utils';
+
+export const latexPastePlugin = () =>
+    new Plugin({
+        props: {
+            handleDOMEvents: {
+                paste(view, e: Event) {
+                    const event = e as ClipboardEvent;
+                    if (!event.clipboardData || view.state.selection.$from.parent.type.spec.code) {
+                        return false;
+                    }
+
+                    const latexData = getLatexData(event.clipboardData);
+                    if (!latexData) return false;
+
+                    getLoggerFromState(view.state).event({
+                        domEvent: 'paste',
+                        event: 'paste-latex-from-code-editor',
+                        editor: latexData.editor,
+                        editorMode: latexData.mode,
+                        empty: !latexData.value,
+                        dataTypes: event.clipboardData.types,
+                    });
+
+                    const {tr, schema} = view.state;
+                    const mathBlockType = schema.nodes[MathNode.Block];
+
+                    if (!mathBlockType) return false;
+
+                    if (latexData.value) {
+                        const formulas = parseLatexFormulas(latexData.value);
+
+                        if (formulas.length > 0) {
+                            const nodes = formulas.map((formula) =>
+                                mathBlockType.create(null, schema.text(formula)),
+                            );
+                            const fragment = Fragment.from(nodes);
+                            tr.replaceWith(tr.selection.from, tr.selection.to, fragment);
+                        } else {
+                            tr.replaceWith(tr.selection.from, tr.selection.to, Fragment.empty);
+                        }
+                    } else {
+                        tr.replaceWith(tr.selection.from, tr.selection.to, Fragment.empty);
+                    }
+
+                    view.dispatch(tr.scrollIntoView());
+                    e.preventDefault();
+                    return true;
+                },
+            },
+        },
+    });

src/extensions/additional/Math/utils.ts

@@ -0,0 +1,49 @@
+import dd from 'ts-dedent';
+
+import {DataTransferType, isVSCode, tryParseVSCodeData} from 'src/utils/clipboard';
+
+import {LATEX_MODES} from './const';
+
+export function isLatexMode(mode: string | undefined): boolean {
+    if (!mode) return false;
+    return LATEX_MODES.has(mode.toLowerCase());
+}
+
+export function parseLatexFormulas(content: string): string[] {
+    const blocks = content.split(/\n\s*\n/);
+    const formulas: string[] = [];
+
+    for (const block of blocks) {
+        const lines = block
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+
+        if (lines.length > 0) {
+            formulas.push(lines.join('\n'));
+        }
+    }
+
+    return formulas;
+}
+
+export function getLatexData(
+    data: DataTransfer,
+): null | {editor: string; mode: string; value: string} {
+    if (!data.getData(DataTransferType.Text)) return null;
+
+    if (isVSCode(data)) {
+        const vsCodeData = tryParseVSCodeData(data);
+        const mode = vsCodeData?.mode;
+
+        if (mode && isLatexMode(mode)) {
+            return {
+                editor: 'vscode',
+                mode,
+                value: dd(data.getData(DataTransferType.Text)),
+            };
+        }
+    }
+
+    return null;
+}