@portabletext/editor 1.44.15 → 1.45.0

package/lib/_chunks-cjs/editor-provider.cjs

@@ -2670,74 +2670,10 @@ function createOperationToPatches(types2) {
     splitNodePatch
   };
 }
-const insertBreakActionImplementation = ({
-  context,
-  action
-}) => {
-  const keyGenerator = context.keyGenerator, schema2 = context.schema, editor = action.editor;
-  if (!editor.selection)
-    return;
-  const anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
-  if (editor.isTextBlock(focusBlock) && anchorBlockPath[0] === focusBlockPath[0]) {
-    slate.Transforms.splitNodes(editor, {
-      at: editor.selection,
-      always: !0
-    });
-    const [nextBlock, nextBlockPath] = slate.Editor.node(editor, slate.Path.next(focusBlockPath), {
-      depth: 1
-    }), nextChild = slate.Node.child(nextBlock, 0);
-    if (!editor.isTextSpan(nextChild) && slate.Transforms.insertNodes(editor, {
-      _key: context.keyGenerator(),
-      _type: "span",
-      text: "",
-      marks: []
-    }, {
-      at: [nextBlockPath[0], 0]
-    }), slate.Transforms.setSelection(editor, {
-      anchor: {
-        path: [...nextBlockPath, 0],
-        offset: 0
-      },
-      focus: {
-        path: [...nextBlockPath, 0],
-        offset: 0
-      }
-    }), editor.isTextBlock(nextBlock) && nextBlock.markDefs && nextBlock.markDefs.length > 0) {
-      const newMarkDefKeys = /* @__PURE__ */ new Map(), prevNodeSpans = Array.from(slate.Node.children(editor, focusBlockPath)).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = slate.Node.children(editor, nextBlockPath);
-      for (const [child, childPath] of children) {
-        if (!editor.isTextSpan(child))
-          continue;
-        const marks = child.marks ?? [];
-        for (const mark of marks)
-          schema2.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some((prevNodeSpan) => prevNodeSpan.marks?.includes(mark)) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
-        const newMarks = marks.map((mark) => newMarkDefKeys.get(mark) ?? mark);
-        isEqual__default.default(marks, newMarks) || slate.Transforms.setNodes(editor, {
-          marks: newMarks
-        }, {
-          at: childPath
-        });
-      }
-      const newMarkDefs = nextBlock.markDefs.map((markDef) => ({
-        ...markDef,
-        _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
-      }));
-      isEqual__default.default(nextBlock.markDefs, newMarkDefs) || slate.Transforms.setNodes(editor, {
-        markDefs: newMarkDefs
-      }, {
-        at: nextBlockPath,
-        match: (node) => editor.isTextBlock(node)
-      });
-    }
-    return;
-  }
-  slate.Transforms.splitNodes(editor, {
-    always: !0
-  });
-}, insertSoftBreakActionImplementation = ({
+const insertTextActionImplementation = ({
   action
 }) => {
-  slate.insertText(action.editor, `
-`);
+  action.editor.insertText(action.text);
 };
 function isPortableTextSpan(node) {
   return node._type === "span" && "text" in node && typeof node.text == "string" && (typeof node.marks > "u" || Array.isArray(node.marks) && node.marks.every((mark) => typeof mark == "string"));
@@ -3215,6 +3151,18 @@ const addAnnotationActionImplementation = ({
   context,
   action
 }) => {
+  const parsedAnnotation = parseBlocks.parseAnnotation({
+    annotation: {
+      _type: action.annotation.name,
+      ...action.annotation.value
+    },
+    context,
+    options: {
+      refreshKeys: !1
+    }
+  });
+  if (!parsedAnnotation)
+    throw new Error(`Failed to parse annotation ${JSON.stringify(action.annotation)}`);
   const editor = action.editor;
   if (!editor.selection || slate.Range.isCollapsed(editor.selection))
     return;
@@ -3224,15 +3172,15 @@ const addAnnotationActionImplementation = ({
     match: (node) => editor.isTextBlock(node),
     reverse: slate.Range.isBackward(editor.selection)
   });
+  let blockIndex = 0;
   for (const [block, blockPath] of selectedBlocks) {
     if (block.children.length === 0 || block.children.length === 1 && block.children[0].text === "")
       continue;
-    const annotationKey = context.keyGenerator(), markDefs = block.markDefs ?? [];
-    markDefs.find((markDef) => markDef._type === action.annotation.name && markDef._key === annotationKey) === void 0 && (slate.Transforms.setNodes(editor, {
+    const annotationKey = blockIndex === 0 ? parsedAnnotation._key : context.keyGenerator(), markDefs = block.markDefs ?? [];
+    markDefs.find((markDef) => markDef._type === parsedAnnotation._type && markDef._key === annotationKey) === void 0 && (slate.Transforms.setNodes(editor, {
       markDefs: [...markDefs, {
-        _type: action.annotation.name,
-        _key: annotationKey,
-        ...action.annotation.value
+        ...parsedAnnotation,
+        _key: annotationKey
       }]
     }, {
       at: blockPath
@@ -3248,7 +3196,7 @@ const addAnnotationActionImplementation = ({
     for (const [span, path] of children) {
       if (!editor.isTextSpan(span) || !slate.Range.includes(editor.selection, path))
         continue;
-      const marks = span.marks ?? [], existingSameTypeAnnotations = marks.filter((mark) => markDefs.some((markDef) => markDef._key === mark && markDef._type === action.annotation.name));
+      const marks = span.marks ?? [], existingSameTypeAnnotations = marks.filter((mark) => markDefs.some((markDef) => markDef._key === mark && markDef._type === parsedAnnotation._type));
       slate.Transforms.setNodes(editor, {
         marks: [...marks.filter((mark) => !existingSameTypeAnnotations.includes(mark)), annotationKey]
       }, {
@@ -3259,6 +3207,7 @@ const addAnnotationActionImplementation = ({
         _key: span._key
       }];
     }
+    blockIndex++;
   }
   return markDefPath && spanPath && (paths = {
     markDefPath,
@@ -3671,13 +3620,13 @@ const decoratorAddActionImplementation = ({
   context,
   action
 }) => {
-  const editor = action.editor, mark = action.decorator, value = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), manualAnchor = action.offsets?.anchor ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
+  const editor = action.editor, mark = action.decorator, value = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), manualAnchor = action.at?.anchor ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
     value,
-    blockOffset: action.offsets.anchor,
+    blockOffset: action.at.anchor,
     direction: "backward"
-  }) : void 0, manualFocus = action.offsets?.focus ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
+  }) : void 0, manualFocus = action.at?.focus ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
     value,
-    blockOffset: action.offsets.focus,
+    blockOffset: action.at.focus,
     direction: "forward"
   }) : void 0, manualSelection = manualAnchor && manualFocus ? {
     anchor: manualAnchor,
@@ -3779,9 +3728,9 @@ const decoratorAddActionImplementation = ({
 }, deleteActionImplementation = ({
   action
 }) => {
-  const range = toSlateRange(action.selection, action.editor);
+  const range = toSlateRange(action.at, action.editor);
   if (!range)
-    throw new Error(`Failed to get Slate Range for selection ${JSON.stringify(action.selection)}`);
+    throw new Error(`Failed to get Slate Range for selection ${JSON.stringify(action.at)}`);
   action.editor.delete({
     at: range
   });
@@ -3819,10 +3768,7 @@ const decoratorAddActionImplementation = ({
 }) => {
   const value = fromSlateValue(action.editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(action.editor)), selection = util_selectionPointToBlockOffset.blockOffsetsToSelection({
     value,
-    offsets: {
-      anchor: action.anchor,
-      focus: action.focus
-    }
+    offsets: action.at
   });
   if (!selection)
     throw new Error("Unable to find selection from block offsets");
@@ -3857,10 +3803,18 @@ const decoratorAddActionImplementation = ({
   context,
   action
 }) => {
-  if (!context.schema.inlineObjects.some((inlineObject) => inlineObject.name === action.inlineObject.name)) {
-    console.error("Unable to insert unknown inline object");
-    return;
-  }
+  const parsedInlineObject = parseBlocks.parseInlineObject({
+    context,
+    inlineObject: {
+      _type: action.inlineObject.name,
+      ...action.inlineObject.value ?? {}
+    },
+    options: {
+      refreshKeys: !1
+    }
+  });
+  if (!parsedInlineObject)
+    throw new Error(`Failed to parse inline object ${JSON.stringify(action.inlineObject)}`);
   if (!action.editor.selection) {
     console.error("Unable to insert inline object without selection");
     return;
@@ -3876,11 +3830,7 @@ const decoratorAddActionImplementation = ({
   const child = toSlateValue([{
     _type: context.schema.block.name,
     _key: context.keyGenerator(),
-    children: [{
-      _type: action.inlineObject.name,
-      _key: context.keyGenerator(),
-      ...action.inlineObject.value ?? {}
-    }]
+    children: [parsedInlineObject]
   }], {
     schemaTypes: context.schema
   }).at(0)?.children.at(0);
@@ -4063,11 +4013,7 @@ function insertBlock({
     }
   }
 }
-const insertTextActionImplementation = ({
-  action
-}) => {
-  action.editor.insertText(action.text);
-}, moveBlockActionImplementation = ({
+const moveBlockActionImplementation = ({
   action
 }) => {
   const at = [toSlatePath(action.at, action.editor)[0]], to = [toSlatePath(action.to, action.editor)[0]];
@@ -4080,8 +4026,71 @@ const insertTextActionImplementation = ({
 }, selectActionImplementation = ({
   action
 }) => {
-  const newSelection = toSlateRange(action.selection, action.editor);
+  const newSelection = toSlateRange(action.at, action.editor);
   newSelection ? slate.Transforms.select(action.editor, newSelection) : slate.Transforms.deselect(action.editor);
+}, splitBlockActionImplementation = ({
+  context,
+  action
+}) => {
+  const keyGenerator = context.keyGenerator, schema2 = context.schema, editor = action.editor;
+  if (!editor.selection)
+    return;
+  const anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
+  if (editor.isTextBlock(focusBlock) && anchorBlockPath[0] === focusBlockPath[0]) {
+    slate.Transforms.splitNodes(editor, {
+      at: editor.selection,
+      always: !0
+    });
+    const [nextBlock, nextBlockPath] = slate.Editor.node(editor, slate.Path.next(focusBlockPath), {
+      depth: 1
+    }), nextChild = slate.Node.child(nextBlock, 0);
+    if (!editor.isTextSpan(nextChild) && slate.Transforms.insertNodes(editor, {
+      _key: context.keyGenerator(),
+      _type: "span",
+      text: "",
+      marks: []
+    }, {
+      at: [nextBlockPath[0], 0]
+    }), slate.Transforms.setSelection(editor, {
+      anchor: {
+        path: [...nextBlockPath, 0],
+        offset: 0
+      },
+      focus: {
+        path: [...nextBlockPath, 0],
+        offset: 0
+      }
+    }), editor.isTextBlock(nextBlock) && nextBlock.markDefs && nextBlock.markDefs.length > 0) {
+      const newMarkDefKeys = /* @__PURE__ */ new Map(), prevNodeSpans = Array.from(slate.Node.children(editor, focusBlockPath)).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = slate.Node.children(editor, nextBlockPath);
+      for (const [child, childPath] of children) {
+        if (!editor.isTextSpan(child))
+          continue;
+        const marks = child.marks ?? [];
+        for (const mark of marks)
+          schema2.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some((prevNodeSpan) => prevNodeSpan.marks?.includes(mark)) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
+        const newMarks = marks.map((mark) => newMarkDefKeys.get(mark) ?? mark);
+        isEqual__default.default(marks, newMarks) || slate.Transforms.setNodes(editor, {
+          marks: newMarks
+        }, {
+          at: childPath
+        });
+      }
+      const newMarkDefs = nextBlock.markDefs.map((markDef) => ({
+        ...markDef,
+        _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
+      }));
+      isEqual__default.default(nextBlock.markDefs, newMarkDefs) || slate.Transforms.setNodes(editor, {
+        markDefs: newMarkDefs
+      }, {
+        at: nextBlockPath,
+        match: (node) => editor.isTextBlock(node)
+      });
+    }
+    return;
+  }
+  slate.Transforms.splitNodes(editor, {
+    always: !0
+  });
 }, debug$a = debugWithName("behaviors:action"), behaviorActionImplementations = {
   "annotation.add": addAnnotationActionImplementation,
   "annotation.remove": removeAnnotationActionImplementation,
@@ -4099,15 +4108,14 @@ const insertTextActionImplementation = ({
   "history.redo": historyRedoActionImplementation,
   "history.undo": historyUndoActionImplementation,
   "insert.block": insertBlockActionImplementation,
-  "insert.break": insertBreakActionImplementation,
   "insert.inline object": insertInlineObjectActionImplementation,
-  "insert.soft break": insertSoftBreakActionImplementation,
   "insert.span": insertSpanActionImplementation,
   "insert.text": insertTextActionImplementation,
   effect: effectActionImplementation,
   "move.block": moveBlockActionImplementation,
   noop: noopActionImplementation,
-  select: selectActionImplementation
+  select: selectActionImplementation,
+  "split.block": splitBlockActionImplementation
 };
 function performAction({
   context,
@@ -4240,20 +4248,6 @@ function performAction({
       });
       break;
     }
-    case "insert.break": {
-      behaviorActionImplementations["insert.break"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "insert.soft break": {
-      behaviorActionImplementations["insert.soft break"]({
-        context,
-        action
-      });
-      break;
-    }
     case "insert.span": {
       behaviorActionImplementations["insert.span"]({
         context,
@@ -4277,6 +4271,13 @@ function performAction({
     }
     case "noop":
       break;
+    case "split.block": {
+      behaviorActionImplementations["split.block"]({
+        context,
+        action
+      });
+      break;
+    }
     default: {
       behaviorActionImplementations.select({
         context,
@@ -4350,12 +4351,14 @@ function createWithEventListeners(editorActor) {
       });
     }, editor.insertSoftBreak = () => {
       if (isApplyingBehaviorActions(editor)) {
-        insertSoftBreakActionImplementation({
+        insertTextActionImplementation({
           context: {
             keyGenerator: editorActor.getSnapshot().context.keyGenerator,
             schema: editorActor.getSnapshot().context.schema
           },
           action: {
+            text: `
+`,
             editor
           }
         });
@@ -4415,7 +4418,7 @@ function createWithEventListeners(editorActor) {
         type: "behavior event",
         behaviorEvent: {
           type: "select",
-          selection: slateRangeToSelection({
+          at: slateRangeToSelection({
             schema: editorActor.getSnapshot().context.schema,
             editor,
             range
@@ -5148,7 +5151,10 @@ function compileSchemaDefinition(definition) {
       // This avoids the default title which is a title case of the object name
       defaultObjectTitles[blockObject.name]
     ) : blockObject.title,
-    fields: []
+    fields: blockObject.fields?.map((field) => ({
+      name: field.name,
+      type: field.type
+    })) ?? []
   })) ?? [], inlineObjects = definition?.inlineObjects?.map((inlineObject) => types.defineType({
     type: "object",
     // Very naive way to work around `SanitySchema.compile` adding default
@@ -5158,7 +5164,10 @@ function compileSchemaDefinition(definition) {
       // This avoids the default title which is a title case of the object name
       defaultObjectTitles[inlineObject.name]
     ) : inlineObject.title,
-    fields: []
+    fields: inlineObject.fields?.map((field) => ({
+      name: field.name,
+      type: field.type
+    })) ?? []
   })) ?? [], portableTextSchema = types.defineField({
     type: "array",
     name: "portable-text",
@@ -5178,7 +5187,11 @@ function compileSchemaDefinition(definition) {
         annotations: definition?.annotations?.map((annotation) => ({
           name: annotation.name,
           type: "object",
-          title: annotation.title
+          title: annotation.title,
+          fields: annotation.fields?.map((field) => ({
+            name: field.name,
+            type: field.type
+          })) ?? []
         })) ?? []
       },
       lists: definition?.lists?.map((list) => ({
@@ -5251,9 +5264,9 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
     snapshot,
     event
   }) => {
-    const manualSelection = event.offsets ? util_selectionPointToBlockOffset.blockOffsetsToSelection({
+    const manualSelection = event.at ? util_selectionPointToBlockOffset.blockOffsetsToSelection({
       value: snapshot.context.value,
-      offsets: event.offsets
+      offsets: event.at
     }) : null;
     return manualSelection ? !selector_isSelectingEntireBlocks.isActiveDecorator(event.decorator)({
       ...snapshot,
@@ -5309,7 +5322,7 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
     placement: "auto",
     select: "end"
   })] : event.blocks.flatMap((block, index) => index === 0 ? [behavior_core.raise({
-    type: "insert.break"
+    type: "split.block"
   }), behavior_core.raise({
     type: "select.previous block",
     select: "end"
@@ -5345,6 +5358,18 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
     placement: index === 0 ? "auto" : "after",
     select: "end"
   }))]
+}), behavior_core.defineBehavior({
+  on: "insert.break",
+  actions: [() => [behavior_core.raise({
+    type: "split.block"
+  })]]
+}), behavior_core.defineBehavior({
+  on: "insert.soft break",
+  actions: [() => [behavior_core.raise({
+    type: "insert.text",
+    text: `
+`
+  })]]
 })], abstractListItemBehaviors = [behavior_core.defineBehavior({
   on: "list item.add",
   guard: ({
@@ -5491,7 +5516,7 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
     selection
   }) => [behavior_core.raise({
     type: "select",
-    selection
+    at: selection
   })]]
 }), behavior_core.defineBehavior({
   on: "select.next block",
@@ -5514,7 +5539,7 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
     selection
   }) => [behavior_core.raise({
     type: "select",
-    selection
+    at: selection
   })]]
 })], abstractStyleBehaviors = [behavior_core.defineBehavior({
   on: "style.add",
@@ -5692,7 +5717,7 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
       originEvent: event
     }), behavior_core.raise({
       type: "delete",
-      selection
+      at: selection
     })]]
   }),
   behavior_core.defineBehavior({
@@ -5751,7 +5776,7 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
       event
     }) => [behavior_core.raise({
       type: "select",
-      selection: event.position.selection
+      at: event.position.selection
     }), behavior_core.raise({
       type: "deserialize",
       originEvent: event
@@ -5801,7 +5826,7 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
       at: block.path
     })) : [behavior_core.raise({
       type: "delete",
-      selection: dragOrigin.selection
+      at: dragOrigin.selection
     })], behavior_core.raise({
       type: "insert.blocks",
       blocks: event.data,
@@ -5895,7 +5920,7 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
       selection
     }) => [behavior_core.raise({
       type: "delete",
-      selection
+      at: selection
     }), behavior_core.raise({
       type: "deserialize",
       originEvent: event
@@ -5929,7 +5954,7 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
   raiseDeserializationSuccessOrFailure,
   raiseSerializationSuccessOrFailure,
   raiseInsertSoftBreak
-], abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "list item.add", "list item.remove", "list item.toggle", "move.block down", "move.block up", "select.previous block", "select.next block", "serialize", "serialization.success", "serialization.failure", "style.add", "style.remove", "style.toggle"];
+], abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "insert.break", "insert.soft break", "list item.add", "list item.remove", "list item.toggle", "move.block down", "move.block up", "select.previous block", "select.next block", "serialize", "serialization.success", "serialization.failure", "style.add", "style.remove", "style.toggle"];
 function isAbstractBehaviorEvent(event) {
   return abstractBehaviorEventTypes.includes(event.type);
 }