@portabletext/editor 3.2.5 → 3.3.0

package/lib/index.js

@@ -19,10 +19,10 @@ import { setup, fromCallback, assign, and, enqueueActions, emit, assertEvent, ra
 import { compileSchemaDefinitionToPortableTextMemberSchemaTypes, createPortableTextMemberSchemaTypes, portableTextMemberSchemaTypesToSchema } from "@portabletext/sanity-bridge";
 import { htmlToBlocks } from "@portabletext/block-tools";
 import { toHTML } from "@portabletext/to-html";
+import { markdownToPortableText, portableTextToMarkdown } from "@portabletext/markdown";
 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";
@@ -2734,6 +2734,57 @@ function createConverterTextHtml(legacySchema) {
     }
   };
 }
+const converterTextMarkdown = {
+  mimeType: "text/markdown",
+  serialize: ({
+    snapshot,
+    event
+  }) => {
+    if (!snapshot.context.selection)
+      return {
+        type: "serialization.failure",
+        mimeType: "text/markdown",
+        reason: "No selection",
+        originEvent: event.originEvent
+      };
+    const blocks = getSelectedValue(snapshot);
+    return {
+      type: "serialization.success",
+      data: portableTextToMarkdown(blocks),
+      mimeType: "text/markdown",
+      originEvent: event.originEvent
+    };
+  },
+  deserialize: ({
+    snapshot,
+    event
+  }) => {
+    const parsedBlocks = markdownToPortableText(event.data, {
+      keyGenerator: snapshot.context.keyGenerator,
+      schema: snapshot.context.schema
+    }).flatMap((block) => {
+      const parsedBlock = parseBlock({
+        context: snapshot.context,
+        block,
+        options: {
+          normalize: !1,
+          removeUnusedMarkDefs: !0,
+          validateFields: !1
+        }
+      });
+      return parsedBlock ? [parsedBlock] : [];
+    });
+    return parsedBlocks.length === 0 ? {
+      type: "deserialization.failure",
+      mimeType: "text/markdown",
+      reason: "No blocks deserialized"
+    } : {
+      type: "deserialization.success",
+      data: parsedBlocks,
+      mimeType: "text/markdown"
+    };
+  }
+};
 function createConverterTextPlain(legacySchema) {
   return {
     mimeType: "text/plain",
@@ -2797,7 +2848,7 @@ function escapeHtml(str) {
   return String(str).replace(/[&<>"'`=/]/g, (s) => entityMap[s]);
 }
 function createCoreConverters(legacySchema) {
-  return [converterJson, converterPortableText, createConverterTextHtml(legacySchema), createConverterTextPlain(legacySchema)];
+  return [converterJson, converterPortableText, converterTextMarkdown, createConverterTextHtml(legacySchema), createConverterTextPlain(legacySchema)];
 }
 function compileType(rawType) {
   return Schema.compile({
@@ -6509,17 +6560,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 +6577,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 +6633,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 +6684,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 +6744,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 +6764,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 +6834,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 {
@@ -8492,41 +8658,37 @@ const abstractAnnotationBehaviors = [defineBehavior({
     ...event,
     type: "delete"
   })]]
-})], abstractDeserializeBehaviors = [
+})], mimeTypePriority = ["application/x-portable-text", "application/json", "text/markdown", "text/html", "text/plain"];
+function getFirstAvailableData({
+  dataTransfer,
+  startAfter
+}) {
+  const startIndex = startAfter ? mimeTypePriority.indexOf(startAfter) + 1 : 0;
+  for (let index = startIndex; index < mimeTypePriority.length; index++) {
+    const mimeType = mimeTypePriority.at(index);
+    if (!mimeType)
+      continue;
+    const data = dataTransfer.getData(mimeType);
+    if (data)
+      return {
+        mimeType,
+        data
+      };
+  }
+}
+const abstractDeserializeBehaviors = [
   defineBehavior({
     on: "deserialize",
     guard: ({
       event
     }) => {
-      const portableText = event.originEvent.originEvent.dataTransfer.getData("application/x-portable-text");
-      if (portableText)
-        return {
-          type: "deserialize.data",
-          mimeType: "application/x-portable-text",
-          data: portableText,
-          originEvent: event.originEvent
-        };
-      const json = event.originEvent.originEvent.dataTransfer.getData("application/json");
-      if (json)
-        return {
-          type: "deserialize.data",
-          mimeType: "application/json",
-          data: json,
-          originEvent: event.originEvent
-        };
-      const html = event.originEvent.originEvent.dataTransfer.getData("text/html");
-      if (html)
-        return {
-          type: "deserialize.data",
-          mimeType: "text/html",
-          data: html,
-          originEvent: event.originEvent
-        };
-      const text = event.originEvent.originEvent.dataTransfer.getData("text/plain");
-      return text ? {
+      const availableData = getFirstAvailableData({
+        dataTransfer: event.originEvent.originEvent.dataTransfer
+      });
+      return availableData ? {
         type: "deserialize.data",
-        mimeType: "text/plain",
-        data: text,
+        mimeType: availableData.mimeType,
+        data: availableData.data,
         originEvent: event.originEvent
       } : !1;
     },
@@ -8633,37 +8795,18 @@ const abstractAnnotationBehaviors = [defineBehavior({
     guard: ({
       event
     }) => {
-      if (event.mimeType === "application/x-portable-text") {
-        const json = event.originEvent.originEvent.dataTransfer.getData("application/json");
-        if (json)
-          return {
-            type: "deserialize.data",
-            mimeType: "application/json",
-            data: json,
-            originEvent: event.originEvent
-          };
-      }
-      if (event.mimeType === "application/json") {
-        const html = event.originEvent.originEvent.dataTransfer.getData("text/html");
-        if (html)
-          return {
-            type: "deserialize.data",
-            mimeType: "text/html",
-            data: html,
-            originEvent: event.originEvent
-          };
-      }
-      if (event.mimeType === "text/html") {
-        const text = event.originEvent.originEvent.dataTransfer.getData("text/plain");
-        if (text)
-          return {
-            type: "deserialize.data",
-            mimeType: "text/plain",
-            data: text,
-            originEvent: event.originEvent
-          };
-      }
-      return !1;
+      if (event.mimeType === "*/*")
+        return !1;
+      const availableData = getFirstAvailableData({
+        dataTransfer: event.originEvent.originEvent.dataTransfer,
+        startAfter: event.mimeType
+      });
+      return availableData ? {
+        type: "deserialize.data",
+        mimeType: availableData.mimeType,
+        data: availableData.data,
+        originEvent: event.originEvent
+      } : !1;
     },
     actions: [(_, deserializeDataEvent) => [raise(deserializeDataEvent)]]
   }),