@liveblocks/node-prosemirror 2.12.3-emails1 → 2.13.1-emails1

package/dist/index.js

@@ -3,7 +3,7 @@ var _core = require('@liveblocks/core');
 
 // src/version.ts
 var PKG_NAME = "@liveblocks/node-prosemirror";
-var PKG_VERSION = "2.12.3-emails1";
+var PKG_VERSION = "2.13.1-emails1";
 var PKG_FORMAT = "cjs";
 
 // ../../node_modules/@tiptap/core/dist/index.js
@@ -383,6 +383,7 @@ function getSchemaByResolvedExtensions(extensions, editor) {
       draggable: callOrReturn(getExtensionField(extension, "draggable", context)),
       code: callOrReturn(getExtensionField(extension, "code", context)),
       whitespace: callOrReturn(getExtensionField(extension, "whitespace", context)),
+      linebreakReplacement: callOrReturn(getExtensionField(extension, "linebreakReplacement", context)),
       defining: callOrReturn(getExtensionField(extension, "defining", context)),
       isolating: callOrReturn(getExtensionField(extension, "isolating", context)),
       attrs: Object.fromEntries(extensionAttributes.map((extensionAttribute) => {
@@ -465,6 +466,13 @@ function isExtensionRulesEnabled(extension, enabled) {
   }
   return enabled;
 }
+function getHTMLFromFragment(fragment, schema) {
+  const documentFragment = _model.DOMSerializer.fromSchema(schema).serializeFragment(fragment);
+  const temporaryDocument = document.implementation.createHTMLDocument();
+  const container = temporaryDocument.createElement("div");
+  container.appendChild(documentFragment);
+  return container.innerHTML;
+}
 var getTextContentFromNodes = ($from, maxMatch = 500) => {
   let textBefore = "";
   const sliceEndPos = $from.parentOffset;
@@ -569,7 +577,7 @@ function inputRulesPlugin(props) {
       init() {
         return null;
       },
-      apply(tr, prev) {
+      apply(tr, prev, state) {
         const stored = tr.getMeta(plugin);
         if (stored) {
           return stored;
@@ -578,7 +586,13 @@ function inputRulesPlugin(props) {
         const isSimulatedInput = !!simulatedInputMeta;
         if (isSimulatedInput) {
           setTimeout(() => {
-            const { from, text } = simulatedInputMeta;
+            let { text } = simulatedInputMeta;
+            if (typeof text === "string") {
+              text = text;
+            } else {
+              text = getHTMLFromFragment(_model.Fragment.from(text), state.schema);
+            }
+            const { from } = simulatedInputMeta;
             const to = from + text.length;
             run$1({
               editor,
@@ -830,7 +844,12 @@ function pasteRulesPlugin(props) {
   let isPastedFromProseMirror = false;
   let isDroppedFromProseMirror = false;
   let pasteEvent = typeof ClipboardEvent !== "undefined" ? new ClipboardEvent("paste") : null;
-  let dropEvent = typeof DragEvent !== "undefined" ? new DragEvent("drop") : null;
+  let dropEvent;
+  try {
+    dropEvent = typeof DragEvent !== "undefined" ? new DragEvent("drop") : null;
+  } catch (e) {
+    dropEvent = null;
+  }
   const processEvent = ({ state, from, to, rule, pasteEvt }) => {
     const tr = state.tr;
     const chainableState = createChainableState({
@@ -849,7 +868,11 @@ function pasteRulesPlugin(props) {
     if (!handler || !tr.steps.length) {
       return;
     }
-    dropEvent = typeof DragEvent !== "undefined" ? new DragEvent("drop") : null;
+    try {
+      dropEvent = typeof DragEvent !== "undefined" ? new DragEvent("drop") : null;
+    } catch (e) {
+      dropEvent = null;
+    }
     pasteEvent = typeof ClipboardEvent !== "undefined" ? new ClipboardEvent("paste") : null;
     return tr;
   };
@@ -894,7 +917,13 @@ function pasteRulesPlugin(props) {
           return;
         }
         if (isSimulatedPaste) {
-          const { from: from2, text } = simulatedPasteMeta;
+          let { text } = simulatedPasteMeta;
+          if (typeof text === "string") {
+            text = text;
+          } else {
+            text = getHTMLFromFragment(_model.Fragment.from(text), state.schema);
+          }
+          const { from: from2 } = simulatedPasteMeta;
           const to2 = from2 + text.length;
           const pasteEvt = createClipboardPasteEvent(text);
           return processEvent({
@@ -1418,13 +1447,18 @@ function objectIncludes(object1, object2, options = { strict: true }) {
 }
 function findMarkInSet(marks, type, attributes = {}) {
   return marks.find((item) => {
-    return item.type === type && objectIncludes(item.attrs, attributes);
+    return item.type === type && objectIncludes(
+      // Only check equality for the attributes that are provided
+      Object.fromEntries(Object.keys(attributes).map((k) => [k, item.attrs[k]])),
+      attributes
+    );
   });
 }
 function isMarkInSet(marks, type, attributes = {}) {
   return !!findMarkInSet(marks, type, attributes);
 }
-function getMarkRange($pos, type, attributes = {}) {
+function getMarkRange($pos, type, attributes) {
+  var _a;
   if (!$pos || !type) {
     return;
   }
@@ -1435,6 +1469,7 @@ function getMarkRange($pos, type, attributes = {}) {
   if (!start.node || !start.node.marks.some((mark2) => mark2.type === type)) {
     return;
   }
+  attributes = attributes || ((_a = start.node.marks[0]) === null || _a === void 0 ? void 0 : _a.attrs);
   const mark = findMarkInSet([...start.node.marks], type, attributes);
   if (!mark) {
     return;
@@ -1443,8 +1478,7 @@ function getMarkRange($pos, type, attributes = {}) {
   let startPos = $pos.start() + start.offset;
   let endIndex = startIndex + 1;
   let endPos = startPos + start.node.nodeSize;
-  findMarkInSet([...start.node.marks], type, attributes);
-  while (startIndex > 0 && mark.isInSet($pos.parent.child(startIndex - 1).marks)) {
+  while (startIndex > 0 && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)) {
     startIndex -= 1;
     startPos -= $pos.parent.child(startIndex).nodeSize;
   }
@@ -1585,6 +1619,9 @@ function elementFromString(value) {
   return removeWhitespaces(html);
 }
 function createNodeFromContent(content, schema, options) {
+  if (content instanceof _model.Node || content instanceof _model.Fragment) {
+    return content;
+  }
   options = {
     slice: true,
     parseOptions: {},
@@ -1727,6 +1764,14 @@ var insertContentAt = (position, value, options) => ({ tr, dispatch, editor }) =
     if (isOnlyTextContent) {
       if (Array.isArray(value)) {
         newContent = value.map((v) => v.text || "").join("");
+      } else if (value instanceof _model.Fragment) {
+        let text = "";
+        value.forEach((node) => {
+          if (node.text) {
+            text += node.text;
+          }
+        });
+        newContent = text;
       } else if (typeof value === "object" && !!value && !!value.text) {
         newContent = value.text;
       } else {
@@ -2254,18 +2299,22 @@ var setMeta = (key, value) => ({ tr }) => {
 };
 var setNode = (typeOrName, attributes = {}) => ({ state, dispatch, chain }) => {
   const type = getNodeType(typeOrName, state.schema);
+  let attributesToCopy;
+  if (state.selection.$anchor.sameParent(state.selection.$head)) {
+    attributesToCopy = state.selection.$anchor.parent.attrs;
+  }
   if (!type.isTextblock) {
     console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.');
     return false;
   }
   return chain().command(({ commands: commands2 }) => {
-    const canSetBlock = _commands.setBlockType.call(void 0, type, attributes)(state);
+    const canSetBlock = _commands.setBlockType.call(void 0, type, { ...attributesToCopy, ...attributes })(state);
     if (canSetBlock) {
       return true;
     }
     return commands2.clearNodes();
   }).command(({ state: updatedState }) => {
-    return _commands.setBlockType.call(void 0, type, attributes)(updatedState, dispatch);
+    return _commands.setBlockType.call(void 0, type, { ...attributesToCopy, ...attributes })(updatedState, dispatch);
   }).run();
 };
 var setNodeSelection = (position) => ({ tr, dispatch }) => {
@@ -2624,18 +2673,59 @@ var updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }
     tr.selection.ranges.forEach((range) => {
       const from = range.$from.pos;
       const to = range.$to.pos;
-      state.doc.nodesBetween(from, to, (node, pos) => {
-        if (nodeType && nodeType === node.type) {
-          tr.setNodeMarkup(pos, void 0, {
-            ...node.attrs,
+      let lastPos;
+      let lastNode;
+      let trimmedFrom;
+      let trimmedTo;
+      if (tr.selection.empty) {
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          if (nodeType && nodeType === node.type) {
+            trimmedFrom = Math.max(pos, from);
+            trimmedTo = Math.min(pos + node.nodeSize, to);
+            lastPos = pos;
+            lastNode = node;
+          }
+        });
+      } else {
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          if (pos < from && nodeType && nodeType === node.type) {
+            trimmedFrom = Math.max(pos, from);
+            trimmedTo = Math.min(pos + node.nodeSize, to);
+            lastPos = pos;
+            lastNode = node;
+          }
+          if (pos >= from && pos <= to) {
+            if (nodeType && nodeType === node.type) {
+              tr.setNodeMarkup(pos, void 0, {
+                ...node.attrs,
+                ...attributes
+              });
+            }
+            if (markType && node.marks.length) {
+              node.marks.forEach((mark) => {
+                if (markType === mark.type) {
+                  const trimmedFrom2 = Math.max(pos, from);
+                  const trimmedTo2 = Math.min(pos + node.nodeSize, to);
+                  tr.addMark(trimmedFrom2, trimmedTo2, markType.create({
+                    ...mark.attrs,
+                    ...attributes
+                  }));
+                }
+              });
+            }
+          }
+        });
+      }
+      if (lastNode) {
+        if (lastPos !== void 0) {
+          tr.setNodeMarkup(lastPos, void 0, {
+            ...lastNode.attrs,
             ...attributes
           });
         }
-        if (markType && node.marks.length) {
-          node.marks.forEach((mark) => {
+        if (markType && lastNode.marks.length) {
+          lastNode.marks.forEach((mark) => {
             if (markType === mark.type) {
-              const trimmedFrom = Math.max(pos, from);
-              const trimmedTo = Math.min(pos + node.nodeSize, to);
               tr.addMark(trimmedFrom, trimmedTo, markType.create({
                 ...mark.attrs,
                 ...attributes
@@ -2643,7 +2733,7 @@ var updateAttributes = (typeOrName, attributes = {}) => ({ tr, state, dispatch }
             }
           });
         }
-      });
+      }
     });
   }
   return true;