@portabletext/editor 3.2.4 → 3.2.6

package/lib/index.js

@@ -22,7 +22,6 @@ import { toHTML } from "@portabletext/to-html";
 import { Schema } from "@sanity/schema";
 import flatten from "lodash/flatten.js";
 import { set, applyAll, unset, insert, setIfMissing, diffMatchPatch as diffMatchPatch$1 } from "@portabletext/patches";
-import { createDraft, finishDraft } from "immer";
 import { createKeyboardShortcut, code, underline, italic, bold, undo, redo } from "@portabletext/keyboard-shortcuts";
 import isPlainObject from "lodash/isPlainObject.js";
 import { EditorContext } from "./_chunks-es/use-editor.js";
@@ -6509,17 +6508,16 @@ function getParent(context, root, path) {
     return block;
 }
 function applyOperationToPortableText(context, value, operation) {
-  const draft = createDraft({
+  const root = {
     children: value
-  });
+  };
   try {
-    applyOperationToPortableTextDraft(context, draft, operation);
+    return applyOperationToPortableTextImmutable(context, root, operation).children;
   } catch (e) {
-    console.error(e);
+    return console.error(e), value;
   }
-  return finishDraft(draft).children;
 }
-function applyOperationToPortableTextDraft(context, root, operation) {
+function applyOperationToPortableTextImmutable(context, root, operation) {
   switch (operation.type) {
     case "insert_node": {
       const {
@@ -6527,45 +6525,55 @@ function applyOperationToPortableTextDraft(context, root, operation) {
         node: insertedNode
       } = operation, parent = getParent(context, root, path), index = path[path.length - 1];
       if (!parent || index > parent.children.length)
-        break;
+        return root;
       if (path.length === 1) {
         if (isTextBlockNode(context, insertedNode)) {
-          parent.children.splice(index, 0, {
+          const newBlock = {
             ...insertedNode,
             children: insertedNode.children.map((child) => "__inline" in child ? {
               _key: child._key,
               _type: child._type,
               ..."value" in child && typeof child.value == "object" ? child.value : {}
             } : child)
-          });
-          break;
+          };
+          return {
+            ...root,
+            children: insertChildren(root.children, index, newBlock)
+          };
         }
         if (Element$1.isElement(insertedNode) && !("__inline" in insertedNode)) {
-          parent.children.splice(index, 0, {
+          const newBlock = {
             _key: insertedNode._key,
             _type: insertedNode._type,
             ..."value" in insertedNode && typeof insertedNode.value == "object" ? insertedNode.value : {}
-          });
-          break;
+          };
+          return {
+            ...root,
+            children: insertChildren(root.children, index, newBlock)
+          };
         }
       }
       if (path.length === 2) {
+        const blockIndex = path[0];
         if (!isTextBlockNode(context, parent))
-          break;
-        if (isPartialSpanNode(insertedNode)) {
-          parent.children.splice(index, 0, insertedNode);
-          break;
-        }
-        if ("__inline" in insertedNode) {
-          parent.children.splice(index, 0, {
+          return root;
+        let newChild;
+        if (isPartialSpanNode(insertedNode))
+          newChild = insertedNode;
+        else if ("__inline" in insertedNode)
+          newChild = {
             _key: insertedNode._key,
             _type: insertedNode._type,
             ..."value" in insertedNode && typeof insertedNode.value == "object" ? insertedNode.value : {}
-          });
-          break;
-        }
+          };
+        else
+          return root;
+        return updateTextBlockAtIndex(context, root, blockIndex, (block) => ({
+          ...block,
+          children: insertChildren(block.children, index, newChild)
+        }));
       }
-      break;
+      return root;
     }
     case "insert_text": {
       const {
@@ -6573,29 +6581,50 @@ function applyOperationToPortableTextDraft(context, root, operation) {
         offset,
         text
       } = operation;
-      if (text.length === 0) break;
+      if (text.length === 0) return root;
       const span = getSpan(context, root, path);
       if (!span)
-        break;
-      const before = span.text.slice(0, offset), after = span.text.slice(offset);
-      span.text = before + text + after;
-      break;
+        return root;
+      const blockIndex = path[0], childIndex = path[1], before = span.text.slice(0, offset), after = span.text.slice(offset), newSpan = {
+        ...span,
+        text: before + text + after
+      };
+      return updateTextBlockAtIndex(context, root, blockIndex, (block) => ({
+        ...block,
+        children: replaceChild(block.children, childIndex, newSpan)
+      }));
     }
     case "merge_node": {
       const {
         path
       } = operation, node = getNode(context, root, path), prevPath = Path.previous(path), prev = getNode(context, root, prevPath), parent = getParent(context, root, path);
       if (!node || !prev || !parent)
-        break;
+        return root;
       const index = path[path.length - 1];
-      if (isPartialSpanNode(node) && isPartialSpanNode(prev))
-        prev.text += node.text;
-      else if (isTextBlockNode(context, node) && isTextBlockNode(context, prev))
-        prev.children.push(...node.children);
-      else
-        break;
-      parent.children.splice(index, 1);
-      break;
+      if (isPartialSpanNode(node) && isPartialSpanNode(prev)) {
+        const blockIndex = path[0], newPrev = {
+          ...prev,
+          text: prev.text + node.text
+        };
+        return updateTextBlockAtIndex(context, root, blockIndex, (block) => {
+          const newChildren = replaceChild(block.children, index - 1, newPrev);
+          return {
+            ...block,
+            children: removeChildren(newChildren, index)
+          };
+        });
+      }
+      if (isTextBlockNode(context, node) && isTextBlockNode(context, prev)) {
+        const newPrev = {
+          ...prev,
+          children: [...prev.children, ...node.children]
+        }, newChildren = replaceChild(root.children, index - 1, newPrev);
+        return {
+          ...root,
+          children: removeChildren(newChildren, index)
+        };
+      }
+      return root;
     }
     case "move_node": {
       const {
@@ -6603,23 +6632,58 @@ function applyOperationToPortableTextDraft(context, root, operation) {
         newPath
       } = operation;
       if (Path.isAncestor(path, newPath))
-        break;
+        return root;
       const node = getNode(context, root, path), parent = getParent(context, root, path), index = path[path.length - 1];
       if (!node || !parent)
-        break;
-      parent.children.splice(index, 1);
-      const truePath = Path.transform(path, operation), newParent = getNode(context, root, Path.parent(truePath)), newIndex = truePath[truePath.length - 1];
-      if (!newParent || !("children" in newParent) || !Array.isArray(newParent.children))
-        break;
-      newParent.children.splice(newIndex, 0, node);
-      break;
+        return root;
+      let newRoot;
+      if (path.length === 1)
+        newRoot = {
+          ...root,
+          children: removeChildren(root.children, index)
+        };
+      else if (path.length === 2) {
+        const blockIndex = path[0];
+        newRoot = updateTextBlockAtIndex(context, root, blockIndex, (block) => ({
+          ...block,
+          children: removeChildren(block.children, index)
+        }));
+      } else
+        return root;
+      const truePath = Path.transform(path, operation), newIndex = truePath[truePath.length - 1];
+      if (truePath.length === 1)
+        return {
+          ...newRoot,
+          children: insertChildren(newRoot.children, newIndex, node)
+        };
+      if (truePath.length === 2) {
+        const newBlockIndex = truePath[0], newParent = newRoot.children[newBlockIndex];
+        return !newParent || !isTextBlockNode(context, newParent) ? root : updateTextBlockAtIndex(context, newRoot, newBlockIndex, (block) => ({
+          ...block,
+          children: insertChildren(block.children, newIndex, node)
+        }));
+      }
+      return root;
     }
     case "remove_node": {
       const {
         path
       } = operation, index = path[path.length - 1];
-      getParent(context, root, path)?.children.splice(index, 1);
-      break;
+      if (!getParent(context, root, path))
+        return root;
+      if (path.length === 1)
+        return {
+          ...root,
+          children: removeChildren(root.children, index)
+        };
+      if (path.length === 2) {
+        const blockIndex = path[0];
+        return updateTextBlockAtIndex(context, root, blockIndex, (block) => ({
+          ...block,
+          children: removeChildren(block.children, index)
+        }));
+      }
+      return root;
     }
     case "remove_text": {
       const {
@@ -6628,13 +6692,18 @@ function applyOperationToPortableTextDraft(context, root, operation) {
         text
       } = operation;
       if (text.length === 0)
-        break;
+        return root;
       const span = getSpan(context, root, path);
       if (!span)
-        break;
-      const before = span.text.slice(0, offset), after = span.text.slice(offset + text.length);
-      span.text = before + after;
-      break;
+        return root;
+      const blockIndex = path[0], childIndex = path[1], before = span.text.slice(0, offset), after = span.text.slice(offset + text.length), newSpan = {
+        ...span,
+        text: before + after
+      };
+      return updateTextBlockAtIndex(context, root, blockIndex, (block) => ({
+        ...block,
+        children: replaceChild(block.children, childIndex, newSpan)
+      }));
     }
     case "set_node": {
       const {
@@ -6643,48 +6712,68 @@ function applyOperationToPortableTextDraft(context, root, operation) {
         newProperties
       } = operation, node = getNode(context, root, path);
       if (!node || isEditorNode(node))
-        break;
+        return root;
       if (isObjectNode(context, node)) {
-        const valueBefore = "value" in properties && typeof properties.value == "object" ? properties.value : {}, valueAfter = "value" in newProperties && typeof newProperties.value == "object" ? newProperties.value : {};
+        const valueBefore = "value" in properties && typeof properties.value == "object" ? properties.value : {}, valueAfter = "value" in newProperties && typeof newProperties.value == "object" ? newProperties.value : {}, newNode = {
+          ...node
+        };
         for (const key in newProperties) {
           if (key === "value")
             continue;
           const value = newProperties[key];
-          value == null ? delete node[key] : node[key] = value;
+          value == null ? delete newNode[key] : newNode[key] = value;
         }
         for (const key in properties)
-          key !== "value" && (newProperties.hasOwnProperty(key) || delete node[key]);
+          key !== "value" && (newProperties.hasOwnProperty(key) || delete newNode[key]);
         for (const key in valueAfter) {
           const value = valueAfter[key];
-          value == null ? delete node[key] : node[key] = value;
+          value == null ? delete newNode[key] : newNode[key] = value;
         }
         for (const key in valueBefore)
-          valueAfter.hasOwnProperty(key) || delete node[key];
-        break;
+          valueAfter.hasOwnProperty(key) || delete newNode[key];
+        return path.length === 1 ? {
+          ...root,
+          children: replaceChild(root.children, path[0], newNode)
+        } : path.length === 2 ? updateTextBlockAtIndex(context, root, path[0], (block) => ({
+          ...block,
+          children: replaceChild(block.children, path[1], newNode)
+        })) : root;
       }
       if (isTextBlockNode(context, node)) {
+        const newNode = {
+          ...node
+        };
         for (const key in newProperties) {
           if (key === "children" || key === "text")
-            break;
+            continue;
           const value = newProperties[key];
-          value == null ? delete node[key] : node[key] = value;
+          value == null ? delete newNode[key] : newNode[key] = value;
         }
         for (const key in properties)
-          newProperties.hasOwnProperty(key) || delete node[key];
-        break;
+          newProperties.hasOwnProperty(key) || delete newNode[key];
+        return {
+          ...root,
+          children: replaceChild(root.children, path[0], newNode)
+        };
       }
       if (isPartialSpanNode(node)) {
+        const newNode = {
+          ...node
+        };
         for (const key in newProperties) {
           if (key === "text")
-            break;
+            continue;
           const value = newProperties[key];
-          value == null ? delete node[key] : node[key] = value;
+          value == null ? delete newNode[key] : newNode[key] = value;
         }
         for (const key in properties)
-          newProperties.hasOwnProperty(key) || delete node[key];
-        break;
+          newProperties.hasOwnProperty(key) || delete newNode[key];
+        return updateTextBlockAtIndex(context, root, path[0], (block) => ({
+          ...block,
+          children: replaceChild(block.children, path[1], newNode)
+        }));
       }
-      break;
+      return root;
     }
     case "split_node": {
       const {
@@ -6693,40 +6782,65 @@ function applyOperationToPortableTextDraft(context, root, operation) {
         properties
       } = operation;
       if (path.length === 0)
-        break;
+        return root;
       const parent = getParent(context, root, path), index = path[path.length - 1];
       if (!parent)
-        break;
+        return root;
       if (isEditorNode(parent)) {
         const block = getBlock(root, path);
         if (!block || !isTextBlockNode(context, block))
-          break;
-        const before = block.children.slice(0, position), after = block.children.slice(position);
-        block.children = before;
-        const newTextBlockNode = {
+          return root;
+        const before = block.children.slice(0, position), after = block.children.slice(position), updatedTextBlockNode = {
+          ...block,
+          children: before
+        }, newTextBlockNode = {
           ...properties,
           children: after,
           _type: context.schema.block.name
         };
-        parent.children.splice(index + 1, 0, newTextBlockNode);
-        break;
+        return {
+          ...root,
+          children: insertChildren(replaceChild(root.children, index, updatedTextBlockNode), index + 1, newTextBlockNode)
+        };
       }
       if (isTextBlockNode(context, parent)) {
         const node = getNode(context, root, path);
         if (!node || !isSpanNode(context, node))
-          break;
-        const before = node.text.slice(0, position), after = node.text.slice(position);
-        node.text = before;
-        const newSpanNode = {
+          return root;
+        const blockIndex = path[0], before = node.text.slice(0, position), after = node.text.slice(position), updatedSpanNode = {
+          ...node,
+          text: before
+        }, newSpanNode = {
           ...properties,
           text: after
         };
-        parent.children.splice(index + 1, 0, newSpanNode);
+        return updateTextBlockAtIndex(context, root, blockIndex, (block) => ({
+          ...block,
+          children: insertChildren(replaceChild(block.children, index, updatedSpanNode), index + 1, newSpanNode)
+        }));
       }
-      break;
+      return root;
     }
   }
-  return root;
+}
+function insertChildren(children, index, ...nodes) {
+  return [...children.slice(0, index), ...nodes, ...children.slice(index)];
+}
+function removeChildren(children, index, count = 1) {
+  return [...children.slice(0, index), ...children.slice(index + count)];
+}
+function replaceChild(children, index, newChild) {
+  return [...children.slice(0, index), newChild, ...children.slice(index + 1)];
+}
+function updateTextBlockAtIndex(context, root, blockIndex, updater) {
+  const block = root.children.at(blockIndex);
+  if (!block || !isTextBlockNode(context, block))
+    return root;
+  const newBlock = updater(block);
+  return {
+    ...root,
+    children: replaceChild(root.children, blockIndex, newBlock)
+  };
 }
 function pluginUpdateValue(context, editor) {
   const {