markupeditor 0.9.47 → 0.9.49

package/dist/markup-editor.js

@@ -33691,19 +33691,80 @@ function pasteHTML(html, event) {
     view.pasteHTML(html, event);
     stateChanged(view);
 }
+/**
+ * Replace curly quotes/apostrophes with their straight ASCII equivalents. A smart
+ * quote is never something the user typed themselves in this editor -- matches the
+ * same normalization MarkupEditorApp applies to its own Source view text on the way
+ * into the document.
+ * @ignore
+ * @param {string} text
+ * @returns {string}
+ */
+function _normalizeSmartPunctuation(text) {
+    return text
+        .replaceAll('‘', "'").replaceAll('’', "'")
+        .replaceAll('“', '"').replaceAll('”', '"')
+}
 /**
  * Paste the `text` into a code block. Caller determines whether to use this method
  * based on the selection state.
- * 
+ *
  * @param {string}                text    The text to be pasted in a preformatted code block
  */
 function pasteCode(text) {
     const view = activeView();
     if (!view) return
-    view.dispatch(view.state.tr.insertText(text));
+    view.dispatch(view.state.tr.insertText(_normalizeSmartPunctuation(text)));
     stateChanged(view);
 }
 
+/**
+ * ProseMirror's own handlePaste EditorView prop for a REAL DOM paste event (e.g. a
+ * plain browser Cmd+V, distinct from pasteCode's own explicit insertText call -- see
+ * that function's own comment). Only intervenes when the selection is inside a
+ * code_block; returns false (unhandled) for anything else,
+ * letting ProseMirror's default paste behavior take over. Extracted out of
+ * markupeditor.js's inline handlePaste prop so this decision/normalization logic is
+ * testable independent of that prop's own target-closure/callbackInput side effect.
+ * @ignore
+ * @param {EditorView} view
+ * @param {ClipboardEvent} event
+ * @returns {boolean}
+ */
+function handleCodeBlockPaste(view, event) {
+    const { $from } = view.state.selection;
+    const inCodeBlock = $from.parent.type === view.state.schema.nodes.code_block;
+    if (!inCodeBlock || !event?.clipboardData) return false
+    const text = event.clipboardData.getData('text/plain');
+    if (!text) return false
+    view.dispatch(view.state.tr.insertText(_normalizeSmartPunctuation(text)));
+    return true
+}
+
+/**
+ * ProseMirror's transformPastedHTML EditorView prop, run on pasted HTML before it's
+ * parsed into the document, for both a real DOM paste and this file's own
+ * pasteHTML/pasteText. Does not fire for a code_block paste, since handleCodeBlockPaste
+ * already intercepts and returns true before ProseMirror's default paste handling runs.
+ * @ignore
+ * @param {string} html
+ * @returns {string}
+ */
+function transformPastedHTML(html) {
+    return _normalizeSmartPunctuation(html)
+}
+
+/**
+ * ProseMirror's transformPastedText EditorView prop -- the plain-text counterpart to
+ * transformPastedHTML, run when the clipboard is pasted as plain text.
+ * @ignore
+ * @param {string} text
+ * @returns {string}
+ */
+function transformPastedText(text) {
+    return _normalizeSmartPunctuation(text)
+}
+
 /**
  * Do a custom paste operation of "text only", which we will extract from the html
  * ourselves. First we get a node that conforms to the schema, which by definition
@@ -34480,6 +34541,7 @@ function toggleFormatCommand(type) {
         }        if (toggle && view) {
             toggle(state, view.dispatch);
             stateChanged(view);
+            return true
         } else {
             return toggle
         }
@@ -34551,6 +34613,7 @@ function setStyleCommand(style) {
             const newState = view.state.apply(transaction);
             view.updateState(newState);
             stateChanged(view);
+            return true
         } else {    // When checking if active based on state, return true only if different
             return paragraphStyle(state) != style;
         }
@@ -36008,11 +36071,6 @@ function _testKeyCodeFor(key) {
  * @throws {Error}          If `key` contains an unrecognized modifier
  *                          prefix, including the unsupported "Mod-".
  * @returns {boolean}       Whether a handler returned `true` for the key.
- *                          NOT a reliable "the document changed" signal:
- *                          some commands (e.g. setStyleCommand,
- *                          toggleFormatCommand) dispatch without returning
- *                          `true`, so the document can still mutate while
- *                          this returns `false`.
  */
 function testTypeKey(key) {
     const view = activeView();
@@ -43330,19 +43388,12 @@ class MarkupEditor {
                 'delete': () => { setTimeout(() => { callbackInput(target); }, 0); },
             },
             handlePaste(view, event) {
-                const { $from } = view.state.selection;
-                const inCodeBlock = $from.parent.type === view.state.schema.nodes.code_block;
-                if (inCodeBlock && event?.clipboardData) {
-                    const text = event.clipboardData.getData('text/plain');
-                    if (text) {
-                        view.dispatch(view.state.tr.insertText(text));
-                        setTimeout(() => { callbackInput(target); }, 0);
-                        return true
-                    }
-                }
+                const handled = handleCodeBlockPaste(view, event);
                 setTimeout(() => { callbackInput(target); }, 0);
-                return false
+                return handled
             },
+            transformPastedHTML,
+            transformPastedText,
             handleKeyDown(view, event) {
                 switch (event.key) {
                     case 'Enter':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markupeditor",
-  "version": "0.9.47",
+  "version": "0.9.49",
   "description": "A web component and API for WYSIWYG HTML editing.",
   "keywords": [
     "wysiwyg",