fix: fixed #2732, fixed #2786

Author: arnog

CHANGELOG.md

@@ -19,6 +19,24 @@
   - **Accessibility enhancements**: Auto-generated ARIA labels with speakable
     text, MathML fallback for screen readers, keyboard navigation support when
     focusable (Space/Enter to speak formula), automatic `role="img"` attribute
+- **#2732** Pressing the Space key in LaTeX mode now completes the LaTeX command
+  and exits LaTeX mode, similar to pressing Enter. Previously, users typing
+  LaTeX commands like `\alpha` would remain in LaTeX mode until pressing Enter,
+  and incomplete commands would be lost when dismissing dialogs. Now pressing
+  Space after a valid LaTeX command completes it and returns to math mode,
+  making LaTeX input more intuitive and preventing data loss. Additionally, when
+  typing LaTeX commands with mandatory arguments (like `\frac{1}{2}`), the
+  command now auto-completes and exits LaTeX mode when the closing brace of the
+  last mandatory argument is typed. The implementation uses the command registry
+  to determine the exact number of mandatory arguments, ensuring correct
+  behavior for all commands including those with nested arguments.
+- **#2786** Fixed scientific notation handling when creating fractions. When
+  typing scientific notation like `5e-2` or `3.14×10^{-2}` and then pressing `/`
+  to create a fraction, the entire expression now stays together in the
+  numerator instead of being split apart. Previously, only part of the number
+  would be included (e.g., just `2` from `5e-2`), breaking the scientific
+  notation. The fix recognizes both e-notation (`5e-2`, `3.14e+10`) and ×10^
+  notation (`3.14×10^{-2}`, `5×10^3`) as atomic units.
 
 ### Resolved Issues
 

src/editor-mathfield/keyboard-input.ts

@@ -16,10 +16,12 @@ import { moveAfterParent } from '../editor-model/commands-move';
 import { range } from '../editor-model/selection-utils';
 
 import {
-  acceptCommandSuggestion,
+  complete,
   removeSuggestion,
   updateAutocomplete,
 } from './autocomplete';
+import { getLatexGroupBody } from './mode-editor-latex';
+import { getDefinition } from '../latex-commands/definitions-utils';
 import { requestUpdate } from './render';
 import type { _Mathfield } from './mathfield-private';
 import { removeIsolatedSpace, smartMode } from './smartmode';
@@ -244,6 +246,20 @@ export function onKeystroke(
       return success;
     }
 
+    // Handle Space key in LaTeX mode to complete and exit
+    if (keystroke === '[Space]' && model.mode === 'latex') {
+      // Try to complete the LaTeX command and exit LaTeX mode
+      if (complete(mathfield, 'accept-all')) {
+        mathfield.dirty = true;
+        mathfield.scrollIntoView();
+        if (evt.preventDefault) {
+          evt.preventDefault();
+          evt.stopPropagation();
+        }
+        return false;
+      }
+    }
+
     if ((!selector || keystroke === '[Space]') && model.mode === 'math') {
       //
       // 5.5 If this is the Space bar and we're just before or right after
@@ -254,18 +270,6 @@ export function onKeystroke(
         // (the bias is reset when the selection changes)
         mathfield.styleBias = 'none';
 
-        // Check if there's an active autocomplete suggestion and accept it
-        if (acceptCommandSuggestion(model)) {
-          mathfield.snapshot('accept-suggestion');
-          mathfield.dirty = true;
-          mathfield.scrollIntoView();
-          if (evt.preventDefault) {
-            evt.preventDefault();
-            evt.stopPropagation();
-          }
-          return false;
-        }
-
         // The space bar can be used to separate inline shortcuts
         mathfield.flushInlineShortcutBuffer();
 
@@ -595,6 +599,60 @@ export function onInput(
         updateAutocomplete(mathfield);
       }
     );
+
+    // Check if we just typed a closing brace that completes all mandatory arguments
+    // This needs to be done AFTER deferNotifications completes
+    if (text === '}') {
+      const latexBody = getLatexGroupBody(model);
+      const latex = latexBody.map((x) => x.value).join('');
+
+      // Extract the command name (e.g., "\frac" from "\frac{1}{2}")
+      const commandMatch = latex.match(/^\\([a-zA-Z]+)/);
+      if (!commandMatch) return;
+
+      const commandName = '\\' + commandMatch[1];
+
+      // Look up the command definition
+      const def = getDefinition(commandName, 'math');
+      if (!def || def.definitionType !== 'function') return;
+
+      // Count the number of mandatory (non-optional) arguments
+      const mandatoryArgCount = def.params.filter((p) => !p.isOptional).length;
+      if (mandatoryArgCount === 0) return;
+
+      // Count how many complete brace pairs we have at the top level
+      let depth = 0;
+      let completedBraces = 0;
+      let inCommandName = true;
+
+      for (let i = 0; i < latex.length; i++) {
+        const char = latex[i];
+
+        // Skip the command name itself
+        if (inCommandName) {
+          if (char === '\\' || /[a-zA-Z]/.test(char)) continue;
+          inCommandName = false;
+        }
+
+        if (char === '{') {
+          depth++;
+        } else if (char === '}') {
+          depth--;
+          // Count a completed brace pair when we return to depth 0
+          if (depth === 0) completedBraces++;
+        }
+      }
+
+      // Auto-complete only if we've completed all mandatory arguments
+      // (depth is 0 and we have the right number of completed brace pairs)
+      if (depth === 0 && completedBraces === mandatoryArgCount) {
+        if (complete(mathfield, 'accept-all')) {
+          mathfield.dirty = true;
+          mathfield.scrollIntoView();
+          return;
+        }
+      }
+    }
   } else if (model.mode === 'text') {
     const style = { ...getSelectionStyle(model), ...mathfield.defaultStyle };
     for (const c of graphemes)

src/editor-mathfield/mode-editor-math.ts

@@ -548,6 +548,113 @@ function getImplicitArgOffset(model: _Model): Offset {
   return model.offsetOf(atom);
 }
 
+/**
+ * Check if the atom is part of a scientific notation pattern
+ * Handles both: 5e-2 and 3.14×10^-2 formats
+ */
+function isPartOfScientificNotation(atom: Atom): boolean {
+  // Pattern 1: 'e' notation (e.g., 5e-2, 3.14e+10)
+  // Check if this is 'e' preceded by a digit
+  if (atom.type === 'mord' && atom.value === 'e') {
+    const left = atom.leftSibling;
+    if (left && left.isDigit()) return true;
+  }
+
+  // Check if this is '+' or '-' preceded by 'e' and that 'e' is preceded by a digit
+  // Note: minus might be '-' (hyphen-minus) or '−' (minus sign U+2212)
+  if (
+    atom.type === 'mbin' &&
+    (atom.value === '+' || atom.value === '-' || atom.value === '−')
+  ) {
+    const left = atom.leftSibling;
+    const right = atom.rightSibling;
+    if (
+      left &&
+      left.type === 'mord' &&
+      left.value === 'e' &&
+      right &&
+      right.isDigit()
+    ) {
+      const leftLeft = left.leftSibling;
+      if (leftLeft && leftLeft.isDigit()) return true;
+    }
+  }
+
+  // Pattern 2: ×10^ notation (e.g., 3.14×10^-2, 5×10^3)
+  // The structure is: digit(s) × 1 0 subsup
+  // where the subsup has the exponent in its superscript branch
+
+  // Check if this is a subsup atom (the ^ part after 10)
+  if (atom.type === 'subsup') {
+    // Check if left siblings are "0" and "1"
+    const left1 = atom.leftSibling; // should be "0"
+    if (left1 && left1.isDigit() && left1.value === '0') {
+      const left2 = left1.leftSibling; // should be "1"
+      if (left2 && left2.isDigit() && left2.value === '1') {
+        // Check if preceded by × (times)
+        const left3 = left2.leftSibling;
+        if (left3 && left3.type === 'mbin' && (left3.value === '×' || left3.value === '\\times')) {
+          // Check if the times is preceded by a digit
+          const left4 = left3.leftSibling;
+          if (left4 && left4.isDigit()) return true;
+        }
+      }
+    }
+  }
+
+  // Check if this is "0" that's part of "10^"
+  if (atom.isDigit() && atom.value === '0') {
+    const left = atom.leftSibling; // should be "1"
+    const right = atom.rightSibling; // should be subsup
+    if (
+      left && left.isDigit() && left.value === '1' &&
+      right && right.type === 'subsup'
+    ) {
+      // Check if "1" is preceded by ×
+      const left2 = left.leftSibling;
+      if (left2 && left2.type === 'mbin' && (left2.value === '×' || left2.value === '\\times')) {
+        // Check if × is preceded by a digit
+        const left3 = left2.leftSibling;
+        if (left3 && left3.isDigit()) return true;
+      }
+    }
+  }
+
+  // Check if this is "1" that's part of "10^"
+  if (atom.isDigit() && atom.value === '1') {
+    const right1 = atom.rightSibling; // should be "0"
+    if (right1 && right1.isDigit() && right1.value === '0') {
+      const right2 = right1.rightSibling; // should be subsup
+      if (right2 && right2.type === 'subsup') {
+        // Check if preceded by ×
+        const left = atom.leftSibling;
+        if (left && left.type === 'mbin' && (left.value === '×' || left.value === '\\times')) {
+          // Check if × is preceded by a digit
+          const left2 = left.leftSibling;
+          if (left2 && left2.isDigit()) return true;
+        }
+      }
+    }
+  }
+
+  // Check if this is × (times) in the pattern digit × 10^exponent
+  if (atom.type === 'mbin' && (atom.value === '×' || atom.value === '\\times')) {
+    const left = atom.leftSibling;
+    const right1 = atom.rightSibling; // should be "1"
+    if (left && left.isDigit() && right1 && right1.isDigit() && right1.value === '1') {
+      const right2 = right1.rightSibling; // should be "0"
+      if (right2 && right2.isDigit() && right2.value === '0') {
+        const right3 = right2.rightSibling; // should be subsup
+        if (right3 && right3.type === 'subsup') {
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
 /**
  *
  * Predicate returns true if the atom should be considered an implicit argument.
@@ -559,6 +666,10 @@ function getImplicitArgOffset(model: _Model): Offset {
 function isImplicitArg(atom: Atom): boolean {
   // A digit, or a decimal point
   if (atom.isDigit()) return true;
+
+  // Check for scientific notation patterns
+  if (isPartOfScientificNotation(atom)) return true;
+
   if (
     atom.type &&
     /^(mord|surd|subsup|leftright|mop|mclose)$/.test(atom.type)

src/editor/keyboard-layout.ts

@@ -300,10 +300,10 @@ export function setKeyboardLayout(
 export function getActiveKeyboardLayout(): KeyboardLayout {
   // if ((gKeyboardLayout ?? gKeyboardLayouts[0])?.displayName === 'French')
   //   debugger;
-  console.log(
-    'Active keyboard layout:',
-    (gKeyboardLayout ?? gKeyboardLayouts[0])?.displayName
-  );
+  // console.log(
+  //   'Active keyboard layout:',
+  //   (gKeyboardLayout ?? gKeyboardLayouts[0])?.displayName
+  // );
   return gKeyboardLayout ?? gKeyboardLayouts[0];
 }