@tiptap/core 2.10.4 → 2.11.0

package/dist/index.umd.js

@@ -994,6 +994,8 @@
       const success = handlers.every(handler => handler !== null);
       return success;
   }
+  // When dragging across editors, must get another editor instance to delete selection content.
+  let tiptapDragFromOtherEditor = null;
   const createClipboardPasteEvent = (text) => {
       var _a;
       const event = new ClipboardEvent('paste', {
@@ -1056,11 +1058,21 @@
                       dragSourceElement = ((_a = view.dom.parentElement) === null || _a === void 0 ? void 0 : _a.contains(event.target))
                           ? view.dom.parentElement
                           : null;
+                      if (dragSourceElement) {
+                          tiptapDragFromOtherEditor = editor;
+                      }
+                  };
+                  const handleDragend = () => {
+                      if (tiptapDragFromOtherEditor) {
+                          tiptapDragFromOtherEditor = null;
+                      }
                   };
                   window.addEventListener('dragstart', handleDragstart);
+                  window.addEventListener('dragend', handleDragend);
                   return {
                       destroy() {
                           window.removeEventListener('dragstart', handleDragstart);
+                          window.removeEventListener('dragend', handleDragend);
                       },
                   };
               },
@@ -1069,6 +1081,18 @@
                       drop: (view, event) => {
                           isDroppedFromProseMirror = dragSourceElement === view.dom.parentElement;
                           dropEvent = event;
+                          if (!isDroppedFromProseMirror) {
+                              const dragFromOtherEditor = tiptapDragFromOtherEditor;
+                              if (dragFromOtherEditor) {
+                                  // setTimeout to avoid the wrong content after drop, timeout arg can't be empty or 0
+                                  setTimeout(() => {
+                                      const selection = dragFromOtherEditor.state.selection;
+                                      if (selection) {
+                                          dragFromOtherEditor.commands.deleteRange({ from: selection.from, to: selection.to });
+                                      }
+                                  }, 10);
+                              }
+                          }
                           return false;
                       },
                       paste: (_view, event) => {
@@ -1827,30 +1851,13 @@
       return state.TextSelection.create(doc, minMax(position, minPos, maxPos), minMax(position, minPos, maxPos));
   }
 
-  function isiOS() {
-      return [
-          'iPad Simulator',
-          'iPhone Simulator',
-          'iPod Simulator',
-          'iPad',
-          'iPhone',
-          'iPod',
-      ].includes(navigator.platform)
-          // iPad on iOS 13 detection
-          || (navigator.userAgent.includes('Mac') && 'ontouchend' in document);
-  }
-
   const focus = (position = null, options = {}) => ({ editor, view, tr, dispatch, }) => {
       options = {
           scrollIntoView: true,
           ...options,
       };
       const delayedFocus = () => {
-          // focus within `requestAnimationFrame` breaks focus on iOS
-          // so we have to call this
-          if (isiOS()) {
-              view.dom.focus();
-          }
+          view.dom.focus();
           // For React we have to focus asynchronously. Otherwise wild things happen.
           // see: https://github.com/ueberdosis/tiptap/issues/1520
           requestAnimationFrame(() => {
@@ -2181,6 +2188,19 @@
       return commands$1.joinTextblockForward(state, dispatch);
   };
 
+  function isiOS() {
+      return [
+          'iPad Simulator',
+          'iPhone Simulator',
+          'iPod Simulator',
+          'iPad',
+          'iPhone',
+          'iPod',
+      ].includes(navigator.platform)
+          // iPad on iOS 13 detection
+          || (navigator.userAgent.includes('Mac') && 'ontouchend' in document);
+  }
+
   function isMacOS() {
       return typeof navigator !== 'undefined'
           ? /Mac/.test(navigator.platform)
@@ -2391,11 +2411,12 @@
       return true;
   };
 
-  const selectAll = () => ({ tr, commands }) => {
-      return commands.setTextSelection({
-          from: 0,
-          to: tr.doc.content.size,
-      });
+  const selectAll = () => ({ tr, dispatch }) => {
+      if (dispatch) {
+          const selection = new state.AllSelection(tr.doc);
+          tr.setSelection(selection);
+      }
+      return true;
   };
 
   const selectNodeBackward = () => ({ state, dispatch }) => {
@@ -3082,6 +3103,81 @@
       };
   }
 
+  /**
+   * The actual implementation of the rewriteUnknownContent function
+   */
+  function rewriteUnknownContentInner({ json, validMarks, validNodes, options, rewrittenContent = [], }) {
+      if (json.marks && Array.isArray(json.marks)) {
+          json.marks = json.marks.filter(mark => {
+              const name = typeof mark === 'string' ? mark : mark.type;
+              if (validMarks.has(name)) {
+                  return true;
+              }
+              rewrittenContent.push({
+                  original: JSON.parse(JSON.stringify(mark)),
+                  unsupported: name,
+              });
+              // Just ignore any unknown marks
+              return false;
+          });
+      }
+      if (json.content && Array.isArray(json.content)) {
+          json.content = json.content
+              .map(value => rewriteUnknownContentInner({
+              json: value,
+              validMarks,
+              validNodes,
+              options,
+              rewrittenContent,
+          }).json)
+              .filter(a => a !== null && a !== undefined);
+      }
+      if (json.type && !validNodes.has(json.type)) {
+          rewrittenContent.push({
+              original: JSON.parse(JSON.stringify(json)),
+              unsupported: json.type,
+          });
+          if (json.content && Array.isArray(json.content) && ((options === null || options === void 0 ? void 0 : options.fallbackToParagraph) !== false)) {
+              // Just treat it like a paragraph and hope for the best
+              json.type = 'paragraph';
+              return {
+                  json,
+                  rewrittenContent,
+              };
+          }
+          // or just omit it entirely
+          return {
+              json: null,
+              rewrittenContent,
+          };
+      }
+      return { json, rewrittenContent };
+  }
+  /**
+   * Rewrite unknown nodes and marks within JSON content
+   * Allowing for user within the editor
+   */
+  function rewriteUnknownContent(
+  /**
+   * The JSON content to clean of unknown nodes and marks
+   */
+  json, 
+  /**
+   * The schema to use for validation
+   */
+  schema, 
+  /**
+   * Options for the cleaning process
+   */
+  options) {
+      return rewriteUnknownContentInner({
+          json,
+          validNodes: new Set(Object.keys(schema.nodes)),
+          validMarks: new Set(Object.keys(schema.marks)),
+          options,
+      });
+  }
+
   function canSetMark(state, tr, newMarkType) {
       var _a;
       const { selection } = tr;
@@ -5077,10 +5173,10 @@ img.ProseMirror-separator {
           // ProseMirror tries to drag selectable nodes
           // even if `draggable` is set to `false`
           // this fix prevents that
-          if (!isDraggable && isSelectable && isDragEvent) {
+          if (!isDraggable && isSelectable && isDragEvent && event.target === this.dom) {
               event.preventDefault();
           }
-          if (isDraggable && isDragEvent && !isDragging) {
+          if (isDraggable && isDragEvent && !isDragging && event.target === this.dom) {
               event.preventDefault();
               return false;
           }
@@ -5406,6 +5502,7 @@ img.ProseMirror-separator {
   exports.posToDOMRect = posToDOMRect;
   exports.removeDuplicates = removeDuplicates;
   exports.resolveFocusPosition = resolveFocusPosition;
+  exports.rewriteUnknownContent = rewriteUnknownContent;
   exports.selectionToInsertionEnd = selectionToInsertionEnd;
   exports.splitExtensions = splitExtensions;
   exports.textInputRule = textInputRule;