@drghaliasri/butex 5.5.0 → 5.5.1

package/dist/react.d.mts

@@ -1071,6 +1071,7 @@ type EditorRuntimeApi = {
     getSession: () => EditorSession;
     setSession: (next: EditorSession) => void;
     setUiLocale: (locale: ButexUiLocale) => void;
+    focusInput: () => void;
     performUndo: () => void;
     performRedo: () => void;
     performCopy: () => Promise<void>;

package/dist/react.d.ts

@@ -1071,6 +1071,7 @@ type EditorRuntimeApi = {
     getSession: () => EditorSession;
     setSession: (next: EditorSession) => void;
     setUiLocale: (locale: ButexUiLocale) => void;
+    focusInput: () => void;
     performUndo: () => void;
     performRedo: () => void;
     performCopy: () => Promise<void>;

package/dist/react.js

@@ -4940,7 +4940,8 @@ ${BUTEX_FONT_FACE_CSS}
   transition: box-shadow 0.15s ease, border-color 0.15s ease;
 }
 
-.surface:focus {
+.surface:focus,
+.surface.surface--typing-focus {
   border-color: var(--butex-focus-border, rgba(13, 148, 136, 0.45));
   box-shadow: 0 0 0 3px var(--butex-focus-shadow, rgba(13, 148, 136, 0.12));
 }
@@ -5142,7 +5143,7 @@ function injectBuTeXEditorStyles(doc) {
 
 // src/editor/runtime.ts
 function createEditorRuntime(options) {
-  const { surfaceEl } = options;
+  const { surfaceEl, inputEl } = options;
   const buttonElements = options.buttonElements ?? {};
   const outsidePointerIgnoreSelectors = options.outsidePointerIgnoreSelectors ?? [];
   let session = options.initialSession ?? createStarterSession();
@@ -5156,6 +5157,23 @@ function createEditorRuntime(options) {
   let dragSelecting = false;
   let dragChainId = null;
   let dragChanged = false;
+  let composingInput = false;
+  let pendingCompositionText = null;
+  function resetInputElement() {
+    if (!inputEl) {
+      return;
+    }
+    inputEl.value = "";
+  }
+  function focusInput() {
+    if (!inputEl) {
+      surfaceEl.focus();
+      return;
+    }
+    inputEl.focus({ preventScroll: true });
+    const end = inputEl.value.length;
+    inputEl.setSelectionRange(end, end);
+  }
   function notifySessionChange() {
     options.onSessionChange?.(session);
   }
@@ -5420,7 +5438,7 @@ function createEditorRuntime(options) {
       event.preventDefault();
       event.stopPropagation();
       startDragSelection(chainId, index);
-      surfaceEl.focus();
+      focusInput();
     });
     slot.addEventListener("click", (event) => {
       if (dragChanged) {
@@ -5430,7 +5448,7 @@ function createEditorRuntime(options) {
         return;
       }
       applyTransient((prev) => setCaret(prev, chainId, index));
-      surfaceEl.focus();
+      focusInput();
     });
     if (session.caret.chainId === chainId && session.caret.index === index) {
       const caret = document.createElement("span");
@@ -5462,7 +5480,7 @@ function createEditorRuntime(options) {
       event.preventDefault();
       event.stopPropagation();
       startDragSelection(chainId, indexInChain);
-      surfaceEl.focus();
+      focusInput();
     });
     nodeEl.addEventListener("click", (event) => {
       if (dragChanged) {
@@ -5473,7 +5491,7 @@ function createEditorRuntime(options) {
       }
       event.stopPropagation();
       applyTransient((prev) => selectNode(prev, node.id));
-      surfaceEl.focus();
+      focusInput();
     });
     const body = document.createElement("span");
     body.className = "node-body";
@@ -5508,7 +5526,7 @@ function createEditorRuntime(options) {
     const activeTree = session[activeTreeKey(session.activeSide)];
     surfaceEl.appendChild(buildChain(activeTree));
     if (initialKeyboardFocusPending) {
-      requestAnimationFrame(() => surfaceEl.focus());
+      requestAnimationFrame(focusInput);
       initialKeyboardFocusPending = false;
     }
     notifySessionChange();
@@ -5546,7 +5564,7 @@ function createEditorRuntime(options) {
     }
     session = restored;
     render();
-    surfaceEl.focus();
+    focusInput();
   }
   function performRedo() {
     const restored = restoreRedo(undoRedo, session);
@@ -5555,9 +5573,12 @@ function createEditorRuntime(options) {
     }
     session = restored;
     render();
-    surfaceEl.focus();
+    focusInput();
   }
   function onKeyDown(event) {
+    if (event.isComposing || event.key === "Process" || event.keyCode === 229) {
+      return;
+    }
     const shortcutMod = event.ctrlKey || event.metaKey;
     const keyLower = typeof event.key === "string" ? event.key.toLowerCase() : "";
     if (shortcutMod && !event.altKey && keyLower === "z") {
@@ -5656,6 +5677,70 @@ function createEditorRuntime(options) {
       applyStructural((prev) => insertChar(prev, char));
     }
   }
+  function onBeforeInput(event) {
+    if (composingInput || event.isComposing) {
+      return;
+    }
+    if (event.inputType === "deleteContentBackward") {
+      event.preventDefault();
+      applyStructural((prev) => deleteBackward(prev));
+      resetInputElement();
+      return;
+    }
+    if (event.inputType === "deleteContentForward") {
+      event.preventDefault();
+      applyStructural((prev) => deleteForward(prev));
+      resetInputElement();
+    }
+  }
+  function onInput(event) {
+    if (!inputEl || composingInput) {
+      return;
+    }
+    const inputEvent = event;
+    const text = inputEvent.data ?? inputEl.value;
+    resetInputElement();
+    if (pendingCompositionText !== null && (inputEvent.inputType === "insertFromComposition" || text === pendingCompositionText)) {
+      pendingCompositionText = null;
+      return;
+    }
+    pendingCompositionText = null;
+    if (inputEvent.inputType === "deleteContentBackward") {
+      applyStructural((prev) => deleteBackward(prev));
+      return;
+    }
+    if (inputEvent.inputType === "deleteContentForward") {
+      applyStructural((prev) => deleteForward(prev));
+      return;
+    }
+    if (text) {
+      applyStructural((prev) => pasteText(prev, text));
+    }
+  }
+  function onCompositionStart() {
+    composingInput = true;
+  }
+  function onCompositionEnd(event) {
+    if (!inputEl) {
+      return;
+    }
+    composingInput = false;
+    const text = event.data || inputEl.value;
+    resetInputElement();
+    if (text) {
+      applyStructural((prev) => pasteText(prev, text));
+    }
+    pendingCompositionText = text || null;
+    window.setTimeout(() => {
+      pendingCompositionText = null;
+    }, 0);
+  }
+  function onInputFocus() {
+    surfaceEl.classList.add("surface--typing-focus");
+  }
+  function onInputBlur() {
+    surfaceEl.classList.remove("surface--typing-focus");
+  }
   function isShortcutOnlyEvent(event) {
     if (!(event.ctrlKey || event.metaKey) || event.altKey) {
       return false;
@@ -5705,7 +5790,7 @@ function createEditorRuntime(options) {
     }
     event.preventDefault();
     startDragSelection(resolved.chainId, resolved.slotIndex);
-    surfaceEl.focus();
+    focusInput();
   }
   function onSurfaceClick(event) {
     if (dragChanged) {
@@ -5722,7 +5807,7 @@ function createEditorRuntime(options) {
     } else {
       clearSelectionAndNodeHighlights();
     }
-    surfaceEl.focus();
+    focusInput();
   }
   function onDocumentPointerDown(event) {
     const target = event.target;
@@ -5738,6 +5823,13 @@ function createEditorRuntime(options) {
     clearSelectionAndNodeHighlights();
   }
   surfaceEl.addEventListener("keydown", onKeyDown);
+  inputEl?.addEventListener("keydown", onKeyDown);
+  inputEl?.addEventListener("beforeinput", onBeforeInput);
+  inputEl?.addEventListener("input", onInput);
+  inputEl?.addEventListener("compositionstart", onCompositionStart);
+  inputEl?.addEventListener("compositionend", onCompositionEnd);
+  inputEl?.addEventListener("focus", onInputFocus);
+  inputEl?.addEventListener("blur", onInputBlur);
   document.addEventListener("keydown", onDocumentKeyDown);
   document.addEventListener("mouseup", endDragSelection);
   document.addEventListener("mouseleave", endDragSelection);
@@ -5749,6 +5841,13 @@ function createEditorRuntime(options) {
     render,
     destroy: () => {
       surfaceEl.removeEventListener("keydown", onKeyDown);
+      inputEl?.removeEventListener("keydown", onKeyDown);
+      inputEl?.removeEventListener("beforeinput", onBeforeInput);
+      inputEl?.removeEventListener("input", onInput);
+      inputEl?.removeEventListener("compositionstart", onCompositionStart);
+      inputEl?.removeEventListener("compositionend", onCompositionEnd);
+      inputEl?.removeEventListener("focus", onInputFocus);
+      inputEl?.removeEventListener("blur", onInputBlur);
       document.removeEventListener("keydown", onDocumentKeyDown);
       document.removeEventListener("mouseup", endDragSelection);
       document.removeEventListener("mouseleave", endDragSelection);
@@ -5769,6 +5868,7 @@ function createEditorRuntime(options) {
       uiLocale = locale;
       render();
     },
+    focusInput,
     performUndo,
     performRedo,
     performCopy,
@@ -5776,27 +5876,27 @@ function createEditorRuntime(options) {
     performPaste,
     toggleSide: () => {
       applyTransient((prev) => switchSide(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     toggleSplitLeafTyping: () => {
       applyStructural((prev) => setSplitLeafTyping(prev, !prev.splitLeafTyping));
-      surfaceEl.focus();
+      focusInput();
     },
     toggleArabicReverseNumberTyping: () => {
       applyStructural((prev) => setArabicReverseNumberTyping(prev, !prev.arabicReverseNumberTyping));
-      surfaceEl.focus();
+      focusInput();
     },
     toggleTakweenCharacterFont: () => {
       applyTransient((prev) => toggleTakweenCharacterFont(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     setCurrentCharacterFont: (fontId) => {
       applyTransient((prev) => setCurrentCharacterFont(prev, fontId));
-      surfaceEl.focus();
+      focusInput();
     },
     setCurrentDigitForm: (digitForm) => {
       applyStructural((prev) => setCurrentDigitForm(prev, digitForm));
-      surfaceEl.focus();
+      focusInput();
     },
     insertDelimiterByKind: (kind) => {
       if (kind === "paren") {
@@ -5806,79 +5906,79 @@ function createEditorRuntime(options) {
       } else {
         applyStructural((prev) => insertDelimiterPair(prev, "\\left\\{", "\\right\\}"));
       }
-      surfaceEl.focus();
+      focusInput();
     },
     insertFraction: () => {
       applyStructural((prev) => insertFraction(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     insertFirstDerivative: () => {
       applyStructural((prev) => insertFirstDerivative(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     insertSecondDerivative: () => {
       applyStructural((prev) => insertSecondDerivative(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     insertMatrixEnv: (style, rows, columns) => {
       applyStructural((prev) => insertMatrixEnv(prev, style, rows, columns));
-      surfaceEl.focus();
+      focusInput();
     },
     insertArrayEnv: (rows, columns) => {
       applyStructural((prev) => insertArrayEnv(prev, rows, columns));
-      surfaceEl.focus();
+      focusInput();
     },
     insertAlignedEnv: (rows, columns) => {
       applyStructural((prev) => insertAlignedEnv(prev, rows, columns));
-      surfaceEl.focus();
+      focusInput();
     },
     insertSqrt: () => {
       applyStructural((prev) => insertSqrt(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     insertOverset: () => {
       applyStructural((prev) => insertOverset(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     insertUnderset: () => {
       applyStructural((prev) => insertUnderset(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     insertLimitsSeriesTemplate: (commandId) => {
       applyStructural((prev) => insertLimitsSeriesTemplate(prev, commandId));
-      surfaceEl.focus();
+      focusInput();
     },
     insertAccentPair: () => {
       applyStructural((prev) => insertAccentPair(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     insertAccent: (accentId) => {
       applyStructural((prev) => insertAccent(prev, accentId));
-      surfaceEl.focus();
+      focusInput();
     },
     insertAtomicCommand: (commandId) => {
       applyStructural((prev) => insertAtomicCommand(prev, commandId));
-      surfaceEl.focus();
+      focusInput();
     },
     insertAtomicOperatorCommand: (commandId) => {
       applyStructural((prev) => insertAtomicOperatorCommand(prev, commandId));
-      surfaceEl.focus();
+      focusInput();
     },
     addSup: () => {
       applyStructural((prev) => addSup(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     addSub: () => {
       applyStructural((prev) => addSub(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     removeSup: () => {
       applyStructural((prev) => removeSup(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     removeSub: () => {
       applyStructural((prev) => removeSub(prev));
-      surfaceEl.focus();
+      focusInput();
     },
     setMatrixEnvStyle: (style) => {
       applyStructural((prev) => setMatrixEnvStyle(prev, style));
@@ -5900,7 +6000,7 @@ function createEditorRuntime(options) {
     },
     deleteStructure: () => {
       applyStructural((prev) => deleteStructure(prev));
-      surfaceEl.focus();
+      focusInput();
     }
   };
   render();
@@ -6367,6 +6467,22 @@ var WIDGET_CHROME_CSS = `
   padding: 10px 12px;
 }
 
+.butex-widget .butex-editor-input-bridge {
+  border: 0;
+  font-size: 16px;
+  height: 1px;
+  margin: 0;
+  max-height: 1px;
+  min-height: 1px;
+  opacity: 0;
+  overflow: hidden;
+  padding: 0;
+  pointer-events: none;
+  position: absolute;
+  resize: none;
+  width: 1px;
+}
+
 .butex-widget .toolbar {
   display: flex;
   flex-wrap: wrap;
@@ -7373,6 +7489,7 @@ var ButexEditor = (0, import_react.forwardRef)(
     const messages = equationEditorMessages(uiLocale);
     const wrapperRef = (0, import_react.useRef)(null);
     const surfaceRef = (0, import_react.useRef)(null);
+    const inputRef = (0, import_react.useRef)(null);
     const mathOutputRef = (0, import_react.useRef)(null);
     const renderErrorRef = (0, import_react.useRef)(null);
     const latexLinesRef = (0, import_react.useRef)(null);
@@ -7484,6 +7601,7 @@ ${arabic || currentMessages.empty}`;
       }
       const runtime = createEditorRuntime({
         surfaceEl,
+        inputEl: inputRef.current,
         initialSession,
         defaultSide,
         uiLocale,
@@ -7525,7 +7643,7 @@ ${arabic || currentMessages.empty}`;
       } else {
         runtime.render();
       }
-      surfaceEl.focus();
+      runtime.focusInput();
       return () => {
         runtime.destroy();
         runtimeRef.current = null;
@@ -7539,7 +7657,7 @@ ${arabic || currentMessages.empty}`;
       }
     }, [uiLocale]);
     function focusSurface() {
-      surfaceRef.current?.focus();
+      runtimeRef.current?.focusInput();
     }
     function insertSelectedEnvironment(rows, columns) {
       if (envPaletteMode === "array") {
@@ -8617,6 +8735,20 @@ ${arabic || currentMessages.empty}`;
                 "aria-label": messages.equationEditor
               }
             ),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "textarea",
+              {
+                ref: inputRef,
+                className: "butex-editor-input-bridge",
+                "aria-label": messages.equationEditor,
+                autoCapitalize: "none",
+                autoComplete: "off",
+                autoCorrect: "off",
+                inputMode: "text",
+                spellCheck: false,
+                tabIndex: -1
+              }
+            ),
             /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: renderErrorRef, className: "error", hidden: true })
           ] }),
           /* @__PURE__ */ (0, import_jsx_runtime.jsx)("section", { className: "panel panel-preview", "aria-label": messages.renderPreview, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: mathOutputRef, className: "preview-box" }) }),