lexxy 0.9.26 → 0.9.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5c63b2cb8499843f516d8404a2a7573f93452f753b54672b53d80a60242d0ef
-  data.tar.gz: 13d59b10d606353cbc379ea5e940b40647fbe17a497f11a565c633ca1ae51519
+  metadata.gz: afb455253a99563e4938f9f1634f997fdb3231f52e7b760e53cb590eb4873934
+  data.tar.gz: 8334d0fb26282b75e340e5d5c5eeb65000a876700038331d2f58347865ef6232
 SHA512:
-  metadata.gz: 0e0b6c3b8763c773fbc0ebe6a4d17cc5c8ee00813c48e66151975640daf3866b9a9558128584812aba21de840982ff0273200158b529343fd98b0992641622b8
-  data.tar.gz: 72db851395aea2ad408a62dd78afd2e0cea0843b1484f39a19755f58d6a8a65c482c029bb876d5f109018820bee4b8141365976b35508bfd83adc0c9754dd543
+  metadata.gz: 46e58bf9d6993735988227cea4c883a8cb8f6e485626c8a7a28cce6e128b2d417faaef93ff404b0d0c64505263df7424ef909c91fe463576f9fe0087a823ef31
+  data.tar.gz: 9c5250b597e25d858378e6b219fab8b3c09b6e472f224fff879b22a7b02c85313b3c74a574142566aca9dcc645ceb0691793d30c8b86e1f1cc2c3d5f69382261

data/app/assets/javascript/lexxy.js

@@ -11085,10 +11085,34 @@ class Selection {
 
       this.editor.registerCommand(ie$4, () => {
         this.#syncSelectedClasses();
-      }, io)
+      }, io),
+
+      this.editor.registerCommand(ie$4, () => {
+        this.#preserveFocusOfOtherFields();
+        return false
+      }, lo)
     );
   }
 
+  // Firefox (152+) keeps window.getSelection() anchored inside the editor after focus
+  // moves to another field, and fires document selectionchange for every keystroke
+  // typed there. Lexical reads that stale selection, reconciles, and pulls focus back
+  // into the editor — stealing it mid-typing. When another text-entry field owns focus,
+  // tag the update so Lexical leaves the DOM selection (and with it, focus) alone.
+  #preserveFocusOfOtherFields() {
+    if (this.#anotherFieldIsFocused) {
+      Os(qn);
+    }
+  }
+
+  get #anotherFieldIsFocused() {
+    const rootElement = this.editor.getRootElement();
+    const activeElement = rootElement?.ownerDocument.activeElement;
+
+    return activeElement && !rootElement.contains(activeElement) &&
+      (activeElement.tagName === "INPUT" || activeElement.tagName === "TEXTAREA" || activeElement.isContentEditable)
+  }
+
   #listenForNodeSelections() {
     this.#listeners.track(this.editor.registerCommand(se$5, ({ target }) => {
       if (!qs(target)) return false
@@ -12476,6 +12500,149 @@ BaseNodeInserter.for = (selection) => {
   return inserterClass ? new inserterClass(selection) : selection
 };
 
+// Word and Outlook never emit <ul>/<ol>/<li>. They simulate lists with flat
+// paragraphs that declare their depth in an inline `mso-list:l0 level2 lfo1`
+// and carry the bullet or number glyph in a <span style="mso-list:Ignore">.
+// Nothing downstream understands either, so the items land as plain paragraphs
+// with the marker baked into the text. Rebuild real lists from the level each
+// paragraph declares.
+//
+// Everything this reads lives in inline attributes, so it stays correct after
+// the pasted content formatter has dropped Office's style sheet.
+class OfficeFormatter {
+  constructor(doc) {
+    this.doc = doc;
+  }
+
+  format() {
+    for (const run of this.#listRuns()) {
+      this.#replaceWithLists(run);
+    }
+  }
+
+  // A run is a stretch of Office list paragraphs that are siblings with nothing
+  // but whitespace and Word's conditional comments between them. Anything else
+  // in between (a heading, a plain paragraph) ends one list and starts another.
+  #listRuns() {
+    const runs = [];
+    const claimed = new Set();
+
+    for (const paragraph of this.doc.querySelectorAll("p[style*='mso-list']")) {
+      if (claimed.has(paragraph) || this.#listLevel(paragraph) === null) continue
+
+      const run = [];
+      let node = paragraph;
+      while (node) {
+        run.push(node);
+        claimed.add(node);
+        node = this.#nextListParagraph(node);
+      }
+      runs.push(run);
+    }
+
+    return runs
+  }
+
+  #nextListParagraph(paragraph) {
+    let sibling = paragraph.nextSibling;
+    while (sibling && this.#isIgnorableBetweenListParagraphs(sibling)) {
+      sibling = sibling.nextSibling;
+    }
+
+    if (sibling && sibling.nodeType === Node.ELEMENT_NODE && this.#listLevel(sibling) !== null) {
+      return sibling
+    }
+
+    return null
+  }
+
+  #isIgnorableBetweenListParagraphs(node) {
+    if (node.nodeType === Node.COMMENT_NODE) {
+      return true
+    }
+    return node.nodeType === Node.TEXT_NODE && node.textContent.trim() === ""
+  }
+
+  // Word numbers levels from 1, but a copied selection often starts partway down
+  // a list, so every paragraph declares level3 with no level1 above it. Anchoring
+  // the run at its own shallowest level is what keeps the result from arriving
+  // needlessly deep.
+  #replaceWithLists(paragraphs) {
+    const levels = paragraphs.map((paragraph) => this.#listLevel(paragraph));
+    const baseLevel = Math.min(...levels);
+    const roots = [];
+    const stack = [];
+
+    paragraphs.forEach((paragraph, index) => {
+      const depth = levels[index] - baseLevel + 1;
+      const tagName = this.#listTagName(paragraph);
+
+      while (stack.length > depth) {
+        stack.pop();
+      }
+      if (stack.length === depth && stack[depth - 1].tagName !== tagName.toUpperCase()) {
+        stack.pop();
+      }
+
+      while (stack.length < depth) {
+        const list = this.doc.createElement(tagName);
+        if (stack.length === 0) {
+          roots.push(list);
+        } else {
+          this.#lastItemOf(stack[stack.length - 1]).appendChild(list);
+        }
+        stack.push(list);
+      }
+
+      stack[stack.length - 1].appendChild(this.#createListItem(paragraph));
+    });
+
+    paragraphs[0].replaceWith(...roots);
+    for (const paragraph of paragraphs.slice(1)) {
+      paragraph.remove();
+    }
+  }
+
+  #lastItemOf(list) {
+    if (!list.lastElementChild) {
+      list.appendChild(this.doc.createElement("li"));
+    }
+    return list.lastElementChild
+  }
+
+  // Word writes bullets as the raw glyph of the marker font (Symbol's "·",
+  // Wingdings' "§", Courier New's "o") and numbers as the rendered counter
+  // ("1.", "a)", "iv)"). A bare letter with no delimiter after it is Courier
+  // New's bullet, not a counter, so the delimiter is what tells them apart.
+  #listTagName(paragraph) {
+    const marker = paragraph.querySelector("[style*='mso-list:Ignore']");
+    const text = marker?.textContent || "";
+
+    if (/\d/.test(text) || /^\(?[A-Za-z]+[.)]/.test(text)) {
+      return "ol"
+    }
+    return "ul"
+  }
+
+  #createListItem(paragraph) {
+    for (const marker of paragraph.querySelectorAll("[style*='mso-list:Ignore']")) {
+      marker.remove();
+    }
+
+    const item = this.doc.createElement("li");
+    item.append(...paragraph.childNodes);
+    return item
+  }
+
+  #listLevel(element) {
+    const match = /mso-list:[^;"']*\blevel(\d+)/.exec(element.getAttribute("style") || "");
+    if (match) {
+      return parseInt(match[1], 10)
+    }
+    return null
+  }
+}
+
 class PastedContentFormatter {
   constructor(doc) {
     this.doc = doc;
@@ -12485,6 +12652,7 @@ class PastedContentFormatter {
     this.#stripStyleElements();
     this.#unwrapPlaceholderAnchors();
     this.#stripTableCellColorStyles();
+    new OfficeFormatter(this.doc).format();
     this.#unwrapWrappedListChildren();
     this.#nestStrayListChildren();
     this.#stripStrayListChildren();
@@ -12643,6 +12811,20 @@ class Contents {
     }, { tag });
   }
 
+  // A literal "\n" stays visible in the editor, which Lexical renders with white-space: pre-wrap,
+  // but collapses to a space once serialized to HTML, so it has to become line break nodes.
+  insertTextWithLineBreaks(text) {
+    const normalizedText = text?.replace(/\r\n?/g, "\n");
+    const selection = Qr();
+
+    if (normalizedText?.includes("\n") && Fr(selection)) {
+      selection.insertRawText(normalizedText);
+      return true
+    } else {
+      return false
+    }
+  }
+
   insertAtCursor(...nodes) {
     const selection = this.#insertableSelection();
     const inserter = BaseNodeInserter.for(selection);
@@ -15706,6 +15888,7 @@ class LexicalEditorElement extends HTMLElement {
   #initialize() {
     this.#registerComponents();
     this.#handleEnter();
+    this.#handleReplacementText();
     this.#registerFocusEvents();
     this.#registerHistoryEvents();
     this.#registerFileAcceptFilter();
@@ -15969,6 +16152,14 @@ class LexicalEditorElement extends HTMLElement {
     ));
   }
 
+  #handleReplacementText() {
+    this.#listeners.track(this.editor.registerCommand(
+      ge$3,
+      (event) => event instanceof InputEvent && this.contents.insertTextWithLineBreaks(event.data),
+      oo
+    ));
+  }
+
   #registerFocusEvents() {
     this.#listeners.track(
       registerEventListener(this, "focusin", this.#handleFocusIn),