rme 0.3.0-beta.60 → 0.3.0-beta.62

package/dist/index.mjs

@@ -9706,12 +9706,32 @@ function updateRangeMarks(tr, forceUpdateAll) {
   if (!range || forceUpdateAll) {
     updateNodeMarks(tr, tr.doc, 0, output);
   } else {
+    const rangeEnd = range.end;
     for (const [child, pos] of iterNodeRange(range)) {
+      if (pos < range.start || pos > rangeEnd) {
+        continue;
+      }
       updateNodeMarks(tr, child, pos, output);
     }
   }
-  if (output.length) {
-    tr.step(new BatchSetMarkStep(output));
+  if (output.length === 0) {
+    return false;
+  }
+  const docSize = tr.doc.content.size;
+  const validChunks = [];
+  for (const [from, to, marks] of output) {
+    if (from < 0 || to > docSize || from >= to) {
+      continue;
+    }
+    validChunks.push([from, to, marks]);
+  }
+  if (validChunks.length === 0) {
+    return false;
+  }
+  try {
+    tr.step(new BatchSetMarkStep(validChunks));
+  } catch {
+    return false;
   }
   if (tr.docChanged) {
     return true;
@@ -9745,7 +9765,13 @@ function deleteSimpleInlineMark({
     const { tr, dispatch, state } = props;
     const { $from, $to, empty } = state.selection;
     const textBlockNode = $from.parent;
+    if (!textBlockNode || !textBlockNode.isTextblock) {
+      return false;
+    }
     const textBlockStart = $from.start();
+    if (textBlockStart < 0) {
+      return false;
+    }
     let fromIndex = $from.index();
     let toIndex = $to.index();
     if ($to.textOffset === 0) {
@@ -9774,8 +9800,12 @@ function deleteSimpleInlineMark({
       }
       if (found) {
         if (dispatch) {
-          updateRangeMarks(tr);
-          dispatch(tr);
+          try {
+            updateRangeMarks(tr);
+            dispatch(tr);
+          } catch {
+            return false;
+          }
         }
         return true;
       }
@@ -9841,11 +9871,34 @@ function hasMark(node, mark) {
   return node.marks.some((m) => m.type.name === mark);
 }
 function deleteTextBlockChild(tr, textBlockNode, textBlockStart, childIndex) {
+  if (childIndex < 0 || childIndex >= textBlockNode.childCount) {
+    return tr;
+  }
+  const childNode = textBlockNode.child(childIndex);
+  if (!childNode) {
+    return tr;
+  }
+  const docSize = tr.doc.content.size;
+  if (textBlockStart < 0 || textBlockStart > docSize) {
+    return tr;
+  }
   let offset = textBlockStart;
   for (let i = 0; i < childIndex; i++) {
-    offset += textBlockNode.child(i).nodeSize;
+    const node = textBlockNode.child(i);
+    if (node) {
+      offset += node.nodeSize;
+    }
+  }
+  const deleteFrom = offset;
+  const deleteTo = offset + childNode.nodeSize;
+  if (deleteFrom < 0 || deleteTo > docSize || deleteFrom >= deleteTo) {
+    return tr;
+  }
+  try {
+    return tr.delete(deleteFrom, deleteTo);
+  } catch {
+    return tr;
   }
-  return tr.delete(offset, offset + textBlockNode.child(childIndex).nodeSize);
 }
 
 // src/editor/extensions/Inline/inline-mark-extensions.ts
@@ -10224,9 +10277,26 @@ var LineInlineMarkExtension = class extends PlainExtension8 {
         clearTimeout(timeoutId);
       }
       timeoutId = setTimeout(() => {
+        if (view2.isDestroyed) {
+          timeoutId = null;
+          return;
+        }
+        const currentDoc = view2.state.doc;
+        const currentSelection = view2.state.selection;
+        const { $head, $anchor } = currentSelection;
         applySelectionMarks(view2);
-        const { $head } = view2.state.selection;
-        view2.dispatch(view2.state.tr.setSelection(new TextSelection9($head)));
+        const maxPos = currentDoc.content.size;
+        const validHeadPos = Math.min(Math.max($head.pos, 0), maxPos);
+        const validAnchorPos = Math.min(Math.max($anchor.pos, 0), maxPos);
+        if (validHeadPos >= 0 && validHeadPos <= maxPos && validAnchorPos >= 0 && validAnchorPos <= maxPos) {
+          try {
+            const $validHead = currentDoc.resolve(validHeadPos);
+            const $validAnchor = currentDoc.resolve(validAnchorPos);
+            const newSelection = $validHead.parent === $validAnchor.parent ? TextSelection9.create(currentDoc, validAnchorPos, validHeadPos) : TextSelection9.create(currentDoc, validHeadPos);
+            view2.dispatch(view2.state.tr.setSelection(newSelection));
+          } catch {
+          }
+        }
         timeoutId = null;
       }, 10);
     };
@@ -11450,10 +11520,6 @@ function isDraggingToItself(view, pos) {
   return from <= pos && pos <= to;
 }
 
-// src/editor/extensions/NodeIndicator/node-indicator-plugin.ts
-import { PluginKey } from "@rme-sdk/pm/state";
-var pluginKey = new PluginKey("nodeIndicator");
-
 // src/editor/extensions/NodeIndicator/node-target.ts
 import {
   isElement,
@@ -11623,12 +11689,11 @@ var NodeIndicatorExtension = class extends PlainExtension9 {
       rect: null
     };
     return {
-      key: pluginKey,
       initialState,
       state: {
         init: () => initialState,
         apply: (tr, value) => {
-          const meta = tr.getMeta(pluginKey);
+          const meta = tr.getMeta(this.pluginKey);
           if (meta) {
             return { ...value, ...meta };
           }
@@ -11693,40 +11758,23 @@ var NodeIndicatorExtension = class extends PlainExtension9 {
                 return false;
               }
             }
-            view.dispatch(view.state.tr.setMeta(pluginKey, { node: null, pos: null }));
+            const currentState = this.pluginKey.getState(view.state);
+            if (currentState?.node !== null) {
+              view.dispatch(view.state.tr.setMeta(this.pluginKey, { node: null, pos: null, rect: null }));
+            }
             return false;
           },
           pointermove: (view, event) => {
-            const { x, y } = event;
-            const block = findBlockByCoords(view, x, y);
-            if (!block) {
-              view.dispatch(view.state.tr.setMeta(pluginKey, { node: null, pos: null }));
-              return;
-            }
-            const { node, pos } = block;
-            const element = view.nodeDOM(pos);
-            if (!element || !isHTMLElement3(element)) {
-              view.dispatch(view.state.tr.setMeta(pluginKey, { node: null, pos: null }));
+            if (view.__nodeIndicatorThrottled) {
               return;
             }
-            const $pos = view.state.doc.resolve(pos);
-            if ($pos.depth > 0 && $pos.index($pos.depth) === 0) {
-              const parentPos = $pos.before($pos.depth);
-              const parentNode = $pos.parent;
-              const parentElement = view.nodeDOM(parentPos);
-              const rect = findFirstLineRect(parentElement, element);
-              view.dispatch(
-                view.state.tr.setMeta(pluginKey, {
-                  node: parentNode,
-                  pos: parentPos,
-                  rect: rect || {}
-                })
-              );
-            } else {
-              const rect = findFirstLineRect(void 0, element);
-              view.dispatch(view.state.tr.setMeta(pluginKey, { node, pos, rect: rect || {} }));
-            }
-            return false;
+            ;
+            view.__nodeIndicatorThrottled = true;
+            requestAnimationFrame(() => {
+              ;
+              view.__nodeIndicatorThrottled = false;
+              handlePointerMove(view, event, this.pluginKey);
+            });
           }
         }
       }
@@ -11736,6 +11784,55 @@ var NodeIndicatorExtension = class extends PlainExtension9 {
 function selectionBetween(view, $anchor, $head, bias) {
   return view.someProp("createSelectionBetween", (f) => f(view, $anchor, $head)) || TextSelection12.between($anchor, $head, bias);
 }
+function handlePointerMove(view, event, pluginKey) {
+  const currentState = pluginKey.getState(view.state);
+  const { x, y } = event;
+  const block = findBlockByCoords(view, x, y);
+  if (!block) {
+    if (currentState?.node !== null) {
+      view.dispatch(view.state.tr.setMeta(pluginKey, { node: null, pos: null, rect: null }));
+    }
+    return;
+  }
+  const { node, pos } = block;
+  const element = view.nodeDOM(pos);
+  if (!element || !isHTMLElement3(element)) {
+    if (currentState?.node !== null) {
+      view.dispatch(view.state.tr.setMeta(pluginKey, { node: null, pos: null, rect: null }));
+    }
+    return;
+  }
+  let newNode = node;
+  let newPos = pos;
+  const $pos = view.state.doc.resolve(pos);
+  if ($pos.depth > 0 && $pos.index($pos.depth) === 0) {
+    const parentPos = $pos.before($pos.depth);
+    const parentNode = $pos.parent;
+    newNode = parentNode;
+    newPos = parentPos;
+  }
+  if (currentState?.pos === newPos && currentState?.node && newNode.type === currentState?.node.type) {
+    return;
+  }
+  const newElement = view.nodeDOM(newPos);
+  if (!newElement || !isHTMLElement3(newElement)) {
+    return;
+  }
+  let rect;
+  if ($pos.depth > 0 && $pos.index($pos.depth) === 0) {
+    const parentElement = view.nodeDOM($pos.before($pos.depth));
+    rect = findFirstLineRect(parentElement, newElement);
+  } else {
+    rect = findFirstLineRect(void 0, newElement);
+  }
+  view.dispatch(
+    view.state.tr.setMeta(pluginKey, {
+      node: newNode,
+      pos: newPos,
+      rect: rect || {}
+    })
+  );
+}
 
 // src/editor/extensions/Paragraph/paragraph-extension.ts
 import { ParagraphExtension } from "@rme-sdk/main/extensions";
@@ -13434,38 +13531,32 @@ import { jsx as jsx18, jsxs as jsxs8 } from "react/jsx-runtime";
 var BlockHandler = memo5(() => {
   const { view: editorView } = useRemirrorContext3({ autoUpdate: true });
   const nodeIndicatorExtension = useExtension(NodeIndicatorExtension);
-  const state = nodeIndicatorExtension.getPluginState();
+  const state = nodeIndicatorExtension?.getPluginState();
   const handleClick = () => {
-    if (editorView && nodeIndicatorExtension) {
-      const state2 = nodeIndicatorExtension.getPluginState();
-      if (state2 && state2.pos !== null && state2.node) {
-        const tr = editorView.state.tr;
-        tr.setSelection(NodeSelection4.create(tr.doc, state2.pos));
-        editorView.dispatch(tr);
-      }
+    if (editorView && nodeIndicatorExtension && state && state.pos !== null && state.node) {
+      const tr = editorView.state.tr;
+      tr.setSelection(NodeSelection4.create(tr.doc, state.pos));
+      editorView.dispatch(tr);
     }
   };
   const handleDragStart = (event) => {
-    if (editorView && nodeIndicatorExtension) {
-      const state2 = nodeIndicatorExtension.getPluginState();
-      if (state2 && state2.pos !== null && state2.node && state2.node.isBlock) {
-        let tr = editorView.state.tr;
-        tr = tr.setSelection(NodeSelection4.create(tr.doc, state2.pos));
-        editorView.dispatch(tr);
-        editorView.dom.classList.add("rme-dragging");
-        const dom = editorView.nodeDOM(state2.pos);
-        if (dom && isHTMLElement5(dom)) {
-          if (event.dataTransfer) {
-            event.dataTransfer.effectAllowed = "move";
-          }
-          createDraggingPreview(editorView, state2, event);
-          setViewDragging(editorView, state2);
+    if (editorView && state && state.pos !== null && state.node && state.node.isBlock) {
+      editorView.dom.classList.add("rme-dragging");
+      handleClick();
+      const dom = editorView.nodeDOM(state.pos);
+      if (dom && isHTMLElement5(dom)) {
+        if (event.dataTransfer) {
+          event.dataTransfer.effectAllowed = "move";
         }
+        createDraggingPreview(editorView, state, event);
+        setViewDragging(editorView, state);
       }
     }
   };
   const handleDragEnd = () => {
-    editorView.dom.classList.remove("rme-dragging");
+    if (editorView) {
+      editorView.dom.classList.remove("rme-dragging");
+    }
   };
   if (!editorView || !state?.node) {
     return null;