@37signals/lexxy 0.1.10-beta → 0.1.12-beta

package/dist/lexxy.esm.js

@@ -1,5 +1,5 @@
 import DOMPurify from 'dompurify';
-import { $getSelection, $isRangeSelection, $isTextNode, DecoratorNode, $getNodeByKey, HISTORY_MERGE_TAG, FORMAT_TEXT_COMMAND, PASTE_COMMAND, COMMAND_PRIORITY_LOW, $isNodeSelection, $getRoot, $isLineBreakNode, $isElementNode, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_DOWN_COMMAND, KEY_DELETE_COMMAND, KEY_BACKSPACE_COMMAND, SELECTION_CHANGE_COMMAND, $createNodeSelection, $setSelection, $createParagraphNode, $createTextNode, $isParagraphNode, $insertNodes, $createLineBreakNode, CLEAR_HISTORY_COMMAND, $addUpdateTag, SKIP_DOM_SELECTION_TAG, createEditor, KEY_ENTER_COMMAND, COMMAND_PRIORITY_NORMAL, COMMAND_PRIORITY_HIGH, KEY_TAB_COMMAND, KEY_SPACE_COMMAND } from 'lexical';
+import { $getSelection, $isRangeSelection, $isTextNode, DecoratorNode, $getNodeByKey, HISTORY_MERGE_TAG, FORMAT_TEXT_COMMAND, PASTE_COMMAND, COMMAND_PRIORITY_LOW, $isNodeSelection, $getRoot, $isLineBreakNode, $isElementNode, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ARROW_DOWN_COMMAND, KEY_DELETE_COMMAND, KEY_BACKSPACE_COMMAND, SELECTION_CHANGE_COMMAND, $createNodeSelection, $setSelection, $createParagraphNode, $createTextNode, $isParagraphNode, $insertNodes, $createLineBreakNode, CLEAR_HISTORY_COMMAND, $addUpdateTag, SKIP_DOM_SELECTION_TAG, createEditor, KEY_ENTER_COMMAND, COMMAND_PRIORITY_NORMAL, COMMAND_PRIORITY_HIGH, KEY_TAB_COMMAND, KEY_SPACE_COMMAND } from 'lexical';
 import { $isListNode, $isListItemNode, INSERT_UNORDERED_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND, ListNode, ListItemNode, registerList } from '@lexical/list';
 import { $isQuoteNode, $isHeadingNode, $createQuoteNode, $createHeadingNode, QuoteNode, HeadingNode, registerRichText } from '@lexical/rich-text';
 import { $isCodeNode, $isCodeHighlightNode, CodeNode, CodeHighlightNode, registerCodeHighlighting, CODE_LANGUAGE_FRIENDLY_NAME_MAP, normalizeCodeLang } from '@lexical/code';
@@ -42,6 +42,17 @@ function getListType(node) {
   return null
 }
 
+function isPrintableCharacter(event) {
+  // Ignore if modifier keys are pressed (except Shift for uppercase)
+  if (event.ctrlKey || event.metaKey || event.altKey) return false
+
+  // Ignore special keys
+  if (event.key.length > 1 && event.key !== 'Enter' && event.key !== 'Space') return false
+
+  // Accept single character keys (letters, numbers, punctuation)
+  return event.key.length === 1
+}
+
 class LexicalToolbarElement extends HTMLElement {
   constructor() {
     super();
@@ -482,6 +493,7 @@ class ActionTextAttachmentNode extends DecoratorNode {
           conversion: () => ({
             node: new ActionTextAttachmentNode({
               src: img.getAttribute("src"),
+              caption: img.getAttribute("alt") || "",
               contentType: "image/*",
               width: img.getAttribute("width"),
               height: img.getAttribute("height")
@@ -881,6 +893,8 @@ class CommandDispatcher {
 
   dispatchInsertUnorderedList() {
     const selection = $getSelection();
+    if (!selection) return;
+
     const anchorNode = selection.anchor.getNode();
 
     if (this.selection.isInsideList && anchorNode && getListType(anchorNode) === "bullet") {
@@ -892,6 +906,8 @@ class CommandDispatcher {
 
   dispatchInsertOrderedList() {
     const selection = $getSelection();
+    if (!selection) return;
+
     const anchorNode = selection.anchor.getNode();
 
     if (this.selection.isInsideList && anchorNode && getListType(anchorNode) === "number") {
@@ -1064,11 +1080,14 @@ function nextFrame() {
 class Selection {
   constructor(editorElement) {
     this.editorElement = editorElement;
+    this.editorContentElement = editorElement.editorContentElement;
     this.editor = this.editorElement.editor;
     this.previouslySelectedKeys = new Set();
 
     this.#listenForNodeSelections();
     this.#processSelectionChangeCommands();
+    this.#handleInputWhenDecoratorNodesSelected();
+    this.#containEditorFocus();
   }
 
   clear() {
@@ -1162,6 +1181,21 @@ class Selection {
     return this.#findNextSiblingUp(anchorNode)
   }
 
+  get topLevelNodeAfterCursor() {
+    const { anchorNode, offset } = this.#getCollapsedSelectionData();
+    if (!anchorNode) return null
+
+    if ($isTextNode(anchorNode)) {
+      return this.#getNextNodeFromTextEnd(anchorNode)
+    }
+
+    if ($isElementNode(anchorNode)) {
+      return this.#getNodeAfterElementNode(anchorNode, offset)
+    }
+
+    return this.#findNextSiblingUp(anchorNode)
+  }
+
   get nodeBeforeCursor() {
     const { anchorNode, offset } = this.#getCollapsedSelectionData();
     if (!anchorNode) return null
@@ -1177,6 +1211,21 @@ class Selection {
     return this.#findPreviousSiblingUp(anchorNode)
   }
 
+  get topLevelNodeBeforeCursor() {
+    const { anchorNode, offset } = this.#getCollapsedSelectionData();
+    if (!anchorNode) return null
+
+    if ($isTextNode(anchorNode)) {
+      return this.#getPreviousNodeFromTextStart(anchorNode)
+    }
+
+    if ($isElementNode(anchorNode)) {
+      return this.#getNodeBeforeElementNode(anchorNode, offset)
+    }
+
+    return this.#findPreviousSiblingUp(anchorNode)
+  }
+
   get #contents() {
     return this.editorElement.contents
   }
@@ -1197,9 +1246,9 @@ class Selection {
 
   #processSelectionChangeCommands() {
     this.editor.registerCommand(KEY_ARROW_LEFT_COMMAND, this.#selectPreviousNode.bind(this), COMMAND_PRIORITY_LOW);
-    this.editor.registerCommand(KEY_ARROW_UP_COMMAND, this.#selectPreviousNode.bind(this), COMMAND_PRIORITY_LOW);
     this.editor.registerCommand(KEY_ARROW_RIGHT_COMMAND, this.#selectNextNode.bind(this), COMMAND_PRIORITY_LOW);
-    this.editor.registerCommand(KEY_ARROW_DOWN_COMMAND, this.#selectNextNode.bind(this), COMMAND_PRIORITY_LOW);
+    this.editor.registerCommand(KEY_ARROW_UP_COMMAND, this.#selectPreviousTopLevelNode.bind(this), COMMAND_PRIORITY_LOW);
+    this.editor.registerCommand(KEY_ARROW_DOWN_COMMAND, this.#selectNextTopLevelNode.bind(this), COMMAND_PRIORITY_LOW);
 
     this.editor.registerCommand(KEY_DELETE_COMMAND, this.#deleteSelectedOrNext.bind(this), COMMAND_PRIORITY_LOW);
     this.editor.registerCommand(KEY_BACKSPACE_COMMAND, this.#deletePreviousOrNext.bind(this), COMMAND_PRIORITY_LOW);
@@ -1230,6 +1279,93 @@ class Selection {
     });
   }
 
+  // In Safari, when the only node in the document is an attachment, it won't let you enter text
+  // before/below it. There is probably a better fix here, but this workaround solves the problem until
+  // we find it.
+  #handleInputWhenDecoratorNodesSelected() {
+    this.editor.getRootElement().addEventListener("keydown", (event) => {
+      if (isPrintableCharacter(event)) {
+        this.editor.update(() => {
+          const selection = $getSelection();
+
+          if ($isRangeSelection(selection) && selection.isCollapsed()) {
+            const anchorNode = selection.anchor.getNode();
+            const offset = selection.anchor.offset;
+
+            const nodeBefore = this.#getNodeBeforePosition(anchorNode, offset);
+            const nodeAfter = this.#getNodeAfterPosition(anchorNode, offset);
+
+            if (nodeBefore instanceof DecoratorNode && !nodeBefore.isInline()) {
+              event.preventDefault();
+              this.#contents.createParagraphAfterNode(nodeBefore, event.key);
+              return
+            } else if (nodeAfter instanceof DecoratorNode && !nodeAfter.isInline()) {
+              event.preventDefault();
+              this.#contents.createParagraphBeforeNode(nodeAfter, event.key);
+              return
+            }
+          }
+        });
+      }
+    }, true);
+  }
+
+  #getNodeBeforePosition(node, offset) {
+    if ($isTextNode(node) && offset === 0) {
+      return node.getPreviousSibling()
+    }
+    if ($isElementNode(node) && offset > 0) {
+      return node.getChildAtIndex(offset - 1)
+    }
+    return null
+  }
+
+  #getNodeAfterPosition(node, offset) {
+    if ($isTextNode(node) && offset === node.getTextContentSize()) {
+      return node.getNextSibling()
+    }
+    if ($isElementNode(node)) {
+      return node.getChildAtIndex(offset)
+    }
+    return null
+  }
+
+  #containEditorFocus() {
+    // Workaround for a bizarre Chrome bug where the cursor abandons the editor to focus on not-focusable elements
+    // above when navigating UP/DOWN when Lexical shows its fake cursor on custom decorator nodes.
+    this.editorContentElement.addEventListener("keydown", (event) => {
+      if (event.key === "ArrowUp") {
+        const lexicalCursor = this.editor.getRootElement().querySelector('[data-lexical-cursor]');
+
+        if (lexicalCursor) {
+          let currentElement = lexicalCursor.previousElementSibling;
+          while (currentElement && currentElement.hasAttribute('data-lexical-cursor')) {
+            currentElement = currentElement.previousElementSibling;
+          }
+
+          if (!currentElement) {
+            event.preventDefault();
+          }
+        }
+      }
+
+      if (event.key === "ArrowDown") {
+        const lexicalCursor = this.editor.getRootElement().querySelector('[data-lexical-cursor]');
+
+        if (lexicalCursor) {
+          let currentElement = lexicalCursor.nextElementSibling;
+          while (currentElement && currentElement.hasAttribute('data-lexical-cursor')) {
+            currentElement = currentElement.nextElementSibling;
+          }
+
+          if (!currentElement) {
+            event.preventDefault();
+          }
+        }
+      }
+    }, true);
+  }
+
   #syncSelectedClasses() {
     this.#clearPreviouslyHighlightedItems();
     this.#highlightNewItems();
@@ -1272,6 +1408,22 @@ class Selection {
     }
   }
 
+  async #selectPreviousTopLevelNode() {
+    if (this.current) {
+      await this.#withCurrentNode((currentNode) => currentNode.selectPrevious());
+    } else {
+      this.#selectInLexical(this.topLevelNodeBeforeCursor);
+    }
+  }
+
+  async #selectNextTopLevelNode() {
+    if (this.current) {
+      await this.#withCurrentNode((currentNode) => currentNode.selectNext(0, 0));
+    } else {
+      this.#selectInLexical(this.topLevelNodeAfterCursor);
+    }
+  }
+
   async #withCurrentNode(fn) {
     await nextFrame();
     if (this.current) {
@@ -1826,6 +1978,30 @@ class Contents {
     });
   }
 
+  createParagraphAfterNode(node, text) {
+    const newParagraph = $createParagraphNode();
+    node.insertAfter(newParagraph);
+    newParagraph.selectStart();
+
+    // Insert the typed text
+    if (text) {
+      newParagraph.append($createTextNode(text));
+      newParagraph.select(1, 1); // Place cursor after the text
+    }
+  }
+
+  createParagraphBeforeNode(node, text) {
+    const newParagraph = $createParagraphNode();
+    node.insertBefore(newParagraph);
+    newParagraph.selectStart();
+
+    // Insert the typed text
+    if (text) {
+      newParagraph.append($createTextNode(text));
+      newParagraph.select(1, 1); // Place cursor after the text
+    }
+  }
+
   uploadFile(file) {
     if (!this.editorElement.supportsAttachments) {
       console.warn("This editor does not supports attachments (it's configured with [attachments=false])");
@@ -1860,25 +2036,34 @@ class Contents {
   deleteSelectedNodes() {
     this.editor.update(() => {
       if ($isNodeSelection(this.#selection.current)) {
-        let nodesWereRemoved = false;
-        this.#selection.current.getNodes().forEach((node) => {
+        const nodesToRemove = this.#selection.current.getNodes();
+        if (nodesToRemove.length === 0) return
+
+        // Use splice() instead of node.remove() for proper removal and
+        // reconciliation. Would have issues with removing unintended decorator nodes
+        // with node.remove()
+        nodesToRemove.forEach((node) => {
           const parent = node.getParent();
+          if (!$isElementNode(parent)) return
 
-          node.remove();
+          const children = parent.getChildren();
+          const index = children.indexOf(node);
 
-          if (parent.getType() === "root" && parent.getChildrenSize() === 0) {
-            parent.append($createParagraphNode());
+          if (index >= 0) {
+            parent.splice(index, 1, []);
           }
-
-          nodesWereRemoved = true;
         });
 
-        if (nodesWereRemoved) {
-          this.#selection.clear();
-          this.editor.focus();
-
-          return true
+        // Check if root is empty after all removals
+        const root = $getRoot();
+        if (root.getChildrenSize() === 0) {
+          root.append($createParagraphNode());
         }
+
+        this.#selection.clear();
+        this.editor.focus();
+
+        return true
       }
     });
   }
@@ -2265,6 +2450,9 @@ class Clipboard {
   #handlePastedFiles(clipboardData) {
     if (!this.editorElement.supportsAttachments) return
 
+    const html = clipboardData.getData('text/html');
+    if (html) return // Ignore if image copied from browser since we will load it as a remote image
+
     this.#preservingScrollPosition(() => {
       for (const item of clipboardData.items) {
         const file = item.getAsFile();
@@ -2294,9 +2482,10 @@ class LexicalEditorElement extends HTMLElement {
   static debug = true
   static commands = [ "bold", "italic", "" ]
 
-  static observedAttributes = [ "connected" ]
+  static observedAttributes = [ "connected", "required" ]
 
   #initialValue = ""
+  #validationTextArea = document.createElement("textarea")
 
   constructor() {
     super();
@@ -2329,6 +2518,11 @@ class LexicalEditorElement extends HTMLElement {
     if (name === "connected" && this.isConnected && oldValue != null && oldValue !== newValue) {
       requestAnimationFrame(() => this.#reconnect());
     }
+
+    if (name === "required" && this.isConnected) {
+      this.#validationTextArea.required = this.hasAttribute("required");
+      this.#setValidity();
+    }
   }
 
   formResetCallback() {
@@ -2382,7 +2576,7 @@ class LexicalEditorElement extends HTMLElement {
       $addUpdateTag(SKIP_DOM_SELECTION_TAG);
       const root = $getRoot();
       root.clear();
-      root.append(...this.#parseHtmlIntoLexicalNodes(html));
+      if (html !== "") root.append(...this.#parseHtmlIntoLexicalNodes(html));
       root.select();
 
       this.#toggleEmptyStatus();
@@ -2495,6 +2689,7 @@ class LexicalEditorElement extends HTMLElement {
 
     this.internals.setFormValue(html);
     this._internalFormValue = html;
+    this.#validationTextArea.value = this.#isEmpty ? "" : html;
 
     if (changed) {
       dispatch(this, "lexxy:change");
@@ -2523,7 +2718,7 @@ class LexicalEditorElement extends HTMLElement {
       this.cachedValue = null;
       this.#internalFormValue = this.value;
       this.#toggleEmptyStatus();
-      this.#validateRequired();
+      this.#setValidity();
     }));
   }
 
@@ -2630,11 +2825,11 @@ class LexicalEditorElement extends HTMLElement {
     return !this.editorContentElement.textContent.trim() && !containsVisuallyRelevantChildren(this.editorContentElement)
   }
 
-  #validateRequired() {
-    if (this.hasAttribute("required") && this.#isEmpty) {
-      this.internals.setValidity({ valueMissing: true }, "Please fill out this field.", this.editorContentElement);
-    } else {
+  #setValidity() {
+    if (this.#validationTextArea.validity.valid) {
       this.internals.setValidity({});
+    } else {
+      this.internals.setValidity(this.#validationTextArea.validity, this.#validationTextArea.validationMessage, this.editorContentElement);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@37signals/lexxy",
-  "version": "0.1.10-beta",
+  "version": "0.1.12-beta",
   "description": "Lexxy - A modern rich text editor for Rails.",
   "module": "dist/lexxy.esm.js",
   "type": "module",