@portabletext/editor 1.1.10 → 1.1.11

package/lib/index.js

@@ -801,12 +801,12 @@ function getFocusBlockObject(context) {
 }
 const softReturn = {
   on: "insert soft break",
-  actions: [() => ({ type: "insert text", text: `
-` })]
+  actions: [() => [{ type: "insert text", text: `
+` }]]
 }, breakingVoidBlock = {
   on: "insert break",
   guard: ({ context }) => !!getFocusBlockObject(context),
-  actions: [() => ({ type: "insert text block", decorators: [] })]
+  actions: [() => [{ type: "insert text block", decorators: [] }]]
 }, coreBehaviors = [softReturn, breakingVoidBlock], debug$k = debugWithName("operationToPatches");
 function createOperationToPatches(types2) {
   const textBlockName = types2.block.name;
@@ -1084,14 +1084,12 @@ function createOperationToPatches(types2) {
 }
 function createWithEventListeners(editorActor) {
   return function(editor) {
-    const { deleteBackward, insertBreak, insertSoftBreak, insertText } = editor;
     return editor.deleteBackward = (unit) => {
       editorActor.send({
         type: "behavior event",
         behaviorEvent: {
           type: "delete backward",
-          unit,
-          default: () => deleteBackward(unit)
+          unit
         },
         editor
       });
@@ -1099,8 +1097,7 @@ function createWithEventListeners(editorActor) {
       editorActor.send({
         type: "behavior event",
         behaviorEvent: {
-          type: "insert break",
-          default: insertBreak
+          type: "insert break"
         },
         editor
       });
@@ -1108,8 +1105,7 @@ function createWithEventListeners(editorActor) {
       editorActor.send({
         type: "behavior event",
         behaviorEvent: {
-          type: "insert soft break",
-          default: insertSoftBreak
+          type: "insert soft break"
         },
         editor
       });
@@ -1119,7 +1115,7 @@ function createWithEventListeners(editorActor) {
         behaviorEvent: {
           type: "insert text",
           text,
-          default: () => insertText(text, options)
+          options
         },
         editor
       });
@@ -1612,131 +1608,6 @@ function createWithEditableAPI(editorActor, portableTextEditor, types$1) {
     }), editor;
   };
 }
-function createWithInsertBreak(editorActor, types2) {
-  return function(editor) {
-    const { insertBreak } = editor;
-    return editor.insertBreak = () => {
-      if (!editor.selection) {
-        insertBreak();
-        return;
-      }
-      const [focusSpan] = Array.from(
-        slate.Editor.nodes(editor, {
-          mode: "lowest",
-          at: editor.selection.focus,
-          match: (n) => editor.isTextSpan(n),
-          voids: !1
-        })
-      )[0] ?? [void 0], focusDecorators = focusSpan.marks?.filter(
-        (mark) => types2.decorators.some((decorator) => decorator.value === mark)
-      ) ?? [], focusAnnotations = focusSpan.marks?.filter(
-        (mark) => !types2.decorators.some((decorator) => decorator.value === mark)
-      ) ?? [], focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
-      if (editor.isTextBlock(focusBlock)) {
-        const [start, end] = slate.Range.edges(editor.selection), atTheStartOfBlock = isEqual__default.default(end, {
-          path: [...focusBlockPath, 0],
-          offset: 0
-        });
-        if (atTheStartOfBlock && slate.Range.isCollapsed(editor.selection)) {
-          slate.Editor.insertNode(
-            editor,
-            editor.pteCreateTextBlock({
-              decorators: focusAnnotations.length === 0 ? focusDecorators : [],
-              listItem: focusBlock.listItem,
-              level: focusBlock.level
-            })
-          );
-          const [nextBlockPath] = slate.Path.next(focusBlockPath);
-          slate.Transforms.select(editor, {
-            anchor: { path: [nextBlockPath, 0], offset: 0 },
-            focus: { path: [nextBlockPath, 0], offset: 0 }
-          });
-          return;
-        }
-        const lastFocusBlockChild = focusBlock.children[focusBlock.children.length - 1], atTheEndOfBlock = isEqual__default.default(start, {
-          path: [...focusBlockPath, focusBlock.children.length - 1],
-          offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
-        });
-        if (atTheEndOfBlock && slate.Range.isCollapsed(editor.selection)) {
-          slate.Editor.insertNode(
-            editor,
-            editor.pteCreateTextBlock({
-              decorators: [],
-              listItem: focusBlock.listItem,
-              level: focusBlock.level
-            })
-          );
-          const [nextBlockPath] = slate.Path.next(focusBlockPath);
-          slate.Transforms.setSelection(editor, {
-            anchor: { path: [nextBlockPath, 0], offset: 0 },
-            focus: { path: [nextBlockPath, 0], offset: 0 }
-          });
-          return;
-        }
-        if (!atTheStartOfBlock && !atTheEndOfBlock) {
-          slate.Editor.withoutNormalizing(editor, () => {
-            if (!editor.selection)
-              return;
-            slate.Transforms.splitNodes(editor, {
-              at: editor.selection
-            });
-            const [nextNode, nextNodePath] = slate.Editor.node(
-              editor,
-              slate.Path.next(focusBlockPath),
-              { depth: 1 }
-            );
-            if (slate.Transforms.setSelection(editor, {
-              anchor: { path: [...nextNodePath, 0], offset: 0 },
-              focus: { path: [...nextNodePath, 0], offset: 0 }
-            }), editor.isTextBlock(nextNode) && nextNode.markDefs && nextNode.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, nextNodePath);
-              for (const [child, childPath] of children) {
-                if (!editor.isTextSpan(child))
-                  continue;
-                const marks = child.marks ?? [];
-                for (const mark of marks)
-                  types2.decorators.some(
-                    (decorator) => decorator.value === mark
-                  ) || prevNodeSpans.some(
-                    (prevNodeSpan) => prevNodeSpan.marks?.includes(mark)
-                  ) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(
-                    mark,
-                    editorActor.getSnapshot().context.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 = nextNode.markDefs.map((markDef) => ({
-                ...markDef,
-                _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
-              }));
-              isEqual__default.default(nextNode.markDefs, newMarkDefs) || slate.Transforms.setNodes(
-                editor,
-                { markDefs: newMarkDefs },
-                {
-                  at: nextNodePath,
-                  match: (node) => editor.isTextBlock(node)
-                }
-              );
-            }
-          }), editor.onChange();
-          return;
-        }
-      }
-      insertBreak();
-    }, editor;
-  };
-}
 function withRemoteChanges(editor, fn) {
   const prev = isChangingRemotely(editor) || !1;
   IS_PROCESSING_REMOTE_CHANGES.set(editor, !0), fn(), IS_PROCESSING_REMOTE_CHANGES.set(editor, prev);
@@ -4442,7 +4313,7 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
   ), withPortableTextBlockStyle = createWithPortableTextBlockStyle(
     editorActor,
     schemaTypes
-  ), withPlaceholderBlock = createWithPlaceholderBlock(), withInsertBreak = createWithInsertBreak(editorActor, schemaTypes), withUtils = createWithUtils({
+  ), withPlaceholderBlock = createWithPlaceholderBlock(), withUtils = createWithUtils({
     editorActor,
     schemaTypes,
     portableTextEditor
@@ -4463,9 +4334,7 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
             withUtils(
               withPlaceholderBlock(
                 withPortableTextLists(
-                  withPortableTextSelections(
-                    withEditableAPI(withInsertBreak(e))
-                  )
+                  withPortableTextSelections(withEditableAPI(e))
                 )
               )
             )
@@ -4486,9 +4355,7 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
                     withMaxBlocks(
                       withUndoRedo(
                         withPatches(
-                          withPortableTextSelections(
-                            withEditableAPI(withInsertBreak(e))
-                          )
+                          withPortableTextSelections(withEditableAPI(e))
                         )
                       )
                     )
@@ -4859,35 +4726,162 @@ ${JSON.stringify(pendingPatches.current, null, 2)}`);
     debug$4("Value from props changed, syncing new value"), syncValue(value), isInitialValueFromProps.current && (editorActor.send({ type: "ready" }), isInitialValueFromProps.current = !1);
   }, [editorActor, syncValue, value]), null;
 }
-const EditorActorContext = react.createContext({}), behaviorActionImplementations = {
-  "apply block style": ({ event }) => {
-    for (const path of event.paths) {
+const EditorActorContext = react.createContext({}), insertBreakActionImplementation = ({ context, action }) => {
+  const keyGenerator = context.keyGenerator, schema2 = context.schema, editor = action.editor;
+  if (!editor.selection)
+    return;
+  const [focusSpan] = Array.from(
+    slate.Editor.nodes(editor, {
+      mode: "lowest",
+      at: editor.selection.focus,
+      match: (n) => editor.isTextSpan(n),
+      voids: !1
+    })
+  )[0] ?? [void 0], focusDecorators = focusSpan.marks?.filter(
+    (mark) => schema2.decorators.some((decorator) => decorator.value === mark)
+  ) ?? [], focusAnnotations = focusSpan.marks?.filter(
+    (mark) => !schema2.decorators.some((decorator) => decorator.value === mark)
+  ) ?? [], focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
+  if (editor.isTextBlock(focusBlock)) {
+    const [start, end] = slate.Range.edges(editor.selection), atTheStartOfBlock = isEqual__default.default(end, {
+      path: [...focusBlockPath, 0],
+      offset: 0
+    });
+    if (atTheStartOfBlock && slate.Range.isCollapsed(editor.selection)) {
+      slate.Editor.insertNode(
+        editor,
+        editor.pteCreateTextBlock({
+          decorators: focusAnnotations.length === 0 ? focusDecorators : [],
+          listItem: focusBlock.listItem,
+          level: focusBlock.level
+        })
+      );
+      const [nextBlockPath] = slate.Path.next(focusBlockPath);
+      slate.Transforms.select(editor, {
+        anchor: { path: [nextBlockPath, 0], offset: 0 },
+        focus: { path: [nextBlockPath, 0], offset: 0 }
+      });
+      return;
+    }
+    const lastFocusBlockChild = focusBlock.children[focusBlock.children.length - 1], atTheEndOfBlock = isEqual__default.default(start, {
+      path: [...focusBlockPath, focusBlock.children.length - 1],
+      offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
+    });
+    if (atTheEndOfBlock && slate.Range.isCollapsed(editor.selection)) {
+      slate.Editor.insertNode(
+        editor,
+        editor.pteCreateTextBlock({
+          decorators: [],
+          listItem: focusBlock.listItem,
+          level: focusBlock.level
+        })
+      );
+      const [nextBlockPath] = slate.Path.next(focusBlockPath);
+      slate.Transforms.setSelection(editor, {
+        anchor: { path: [nextBlockPath, 0], offset: 0 },
+        focus: { path: [nextBlockPath, 0], offset: 0 }
+      });
+      return;
+    }
+    if (!atTheStartOfBlock && !atTheEndOfBlock) {
+      slate.Editor.withoutNormalizing(editor, () => {
+        if (!editor.selection)
+          return;
+        slate.Transforms.splitNodes(editor, {
+          at: editor.selection
+        });
+        const [nextNode, nextNodePath] = slate.Editor.node(
+          editor,
+          slate.Path.next(focusBlockPath),
+          { depth: 1 }
+        );
+        if (slate.Transforms.setSelection(editor, {
+          anchor: { path: [...nextNodePath, 0], offset: 0 },
+          focus: { path: [...nextNodePath, 0], offset: 0 }
+        }), editor.isTextBlock(nextNode) && nextNode.markDefs && nextNode.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, nextNodePath);
+          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 = nextNode.markDefs.map((markDef) => ({
+            ...markDef,
+            _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
+          }));
+          isEqual__default.default(nextNode.markDefs, newMarkDefs) || slate.Transforms.setNodes(
+            editor,
+            { markDefs: newMarkDefs },
+            {
+              at: nextNodePath,
+              match: (node) => editor.isTextBlock(node)
+            }
+          );
+        }
+      }), editor.onChange();
+      return;
+    }
+  }
+}, behaviorActionImplementations = {
+  "set block": ({ action }) => {
+    for (const path of action.paths) {
       const at = toSlateRange(
         { anchor: { path, offset: 0 }, focus: { path, offset: 0 } },
-        event.editor
+        action.editor
+      );
+      slate.Transforms.setNodes(
+        action.editor,
+        {
+          ...action.style ? { style: action.style } : {},
+          ...action.listItem ? { listItem: action.listItem } : {},
+          ...action.level ? { level: action.level } : {}
+        },
+        { at }
       );
-      slate.Transforms.setNodes(event.editor, { style: event.style }, { at });
     }
   },
-  "delete backward": ({ event }) => {
-    slate.Editor.deleteBackward(event.editor, { unit: event.unit });
-  },
-  "delete text": ({ event }) => {
-    slate.Transforms.delete(event.editor, {
-      at: toSlateRange(event.selection, event.editor)
-    });
+  "unset block": ({ action }) => {
+    for (const path of action.paths) {
+      const at = toSlateRange(
+        { anchor: { path, offset: 0 }, focus: { path, offset: 0 } },
+        action.editor
+      );
+      slate.Transforms.unsetNodes(action.editor, action.props, { at });
+    }
   },
-  "insert break": ({ event }) => {
-    slate.Editor.insertBreak(event.editor);
+  "delete backward": ({ action }) => {
+    slate.deleteBackward(action.editor, action.unit);
   },
-  "insert soft break": ({ event }) => {
-    slate.Editor.insertSoftBreak(event.editor);
+  "delete text": ({ action }) => {
+    slate.Transforms.delete(action.editor, {
+      at: toSlateRange(action.selection, action.editor)
+    });
   },
-  "insert text": ({ event }) => {
-    slate.Editor.insertText(event.editor, event.text);
+  "insert break": insertBreakActionImplementation,
+  // This mimics Slate's internal which also just does a regular insert break
+  // when on soft break
+  "insert soft break": insertBreakActionImplementation,
+  "insert text": ({ action }) => {
+    slate.insertText(action.editor, action.text);
   },
-  "insert text block": ({ context, event }) => {
-    slate.Editor.insertNode(event.editor, {
+  "insert text block": ({ context, action }) => {
+    slate.Editor.insertNode(action.editor, {
       _key: context.keyGenerator(),
       _type: context.schema.block.name,
       style: context.schema.styles[0].value ?? "normal",
@@ -4900,8 +4894,47 @@ const EditorActorContext = react.createContext({}), behaviorActionImplementation
         }
       ]
     });
+  },
+  effect: ({ action }) => {
+    action.effect();
+  }
+};
+function performDefaultAction({
+  context,
+  action
+}) {
+  switch (action.type) {
+    case "delete backward": {
+      behaviorActionImplementations["delete backward"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "insert break": {
+      behaviorActionImplementations["insert break"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "insert soft break": {
+      behaviorActionImplementations["insert soft break"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "insert text": {
+      behaviorActionImplementations["insert text"]({
+        context,
+        action
+      });
+      break;
+    }
   }
-}, networkLogic = xstate.fromCallback(({ sendBack }) => {
+}
+const networkLogic = xstate.fromCallback(({ sendBack }) => {
   const onlineHandler = () => {
     sendBack({ type: "online" });
   }, offlineHandler = () => {
@@ -4935,11 +4968,14 @@ const EditorActorContext = react.createContext({}), behaviorActionImplementation
     }),
     "handle behavior event": xstate.enqueueActions(({ context, event, enqueue }) => {
       xstate.assertEvent(event, ["behavior event"]);
-      const eventBehaviors = context.behaviors.filter(
+      const defaultAction = {
+        ...event.behaviorEvent,
+        editor: event.editor
+      }, eventBehaviors = context.behaviors.filter(
         (behavior) => behavior.on === event.behaviorEvent.type
       );
       if (eventBehaviors.length === 0) {
-        event.behaviorEvent.default();
+        performDefaultAction({ context, action: defaultAction });
         return;
       }
       const value = fromSlateValue(
@@ -4954,7 +4990,7 @@ const EditorActorContext = react.createContext({}), behaviorActionImplementation
       if (!selection) {
         console.warn(
           `Unable to handle event ${event.type} due to missing selection`
-        ), event.behaviorEvent.default();
+        ), performDefaultAction({ context, action: defaultAction });
         return;
       }
       const behaviorContext = {
@@ -4970,19 +5006,20 @@ const EditorActorContext = react.createContext({}), behaviorActionImplementation
         }) ?? !0;
         if (!shouldRun)
           continue;
-        const actions = eventBehavior.actions.map(
-          (action) => action(
+        const actionIntendSets = eventBehavior.actions.map(
+          (actionSet) => actionSet(
             { context: behaviorContext, event: event.behaviorEvent },
             shouldRun
           )
         );
-        for (const action of actions)
-          typeof action == "object" && (behaviorOverwritten = !0, enqueue.raise({
-            ...action,
-            editor: event.editor
-          }));
+        for (const actionIntends of actionIntendSets)
+          behaviorOverwritten = actionIntends.length > 0 && actionIntends.some((actionIntend) => actionIntend.type !== "effect"), enqueue.raise({
+            type: "behavior action intends",
+            editor: event.editor,
+            actionIntends
+          });
       }
-      behaviorOverwritten || event.behaviorEvent.default();
+      behaviorOverwritten || performDefaultAction({ context, action: defaultAction });
     })
   },
   actors: {
@@ -5015,26 +5052,82 @@ const EditorActorContext = react.createContext({}), behaviorActionImplementation
     "done loading": { actions: xstate.emit({ type: "done loading" }) },
     "update schema": { actions: "assign schema" },
     "behavior event": { actions: "handle behavior event" },
-    "apply block style": {
-      actions: [behaviorActionImplementations["apply block style"]]
-    },
-    "delete backward": {
-      actions: [behaviorActionImplementations["delete backward"]]
-    },
-    "delete text": {
-      actions: [behaviorActionImplementations["delete text"]]
-    },
-    "insert break": {
-      actions: [behaviorActionImplementations["insert break"]]
-    },
-    "insert soft break": {
-      actions: [behaviorActionImplementations["insert soft break"]]
-    },
-    "insert text": {
-      actions: [behaviorActionImplementations["insert text"]]
-    },
-    "insert text block": {
-      actions: [behaviorActionImplementations["insert text block"]]
+    "behavior action intends": {
+      actions: [
+        ({ context, event }) => {
+          slate.Editor.withoutNormalizing(event.editor, () => {
+            for (const actionIntend of event.actionIntends) {
+              const action = {
+                ...actionIntend,
+                editor: event.editor
+              };
+              switch (action.type) {
+                case "delete backward": {
+                  behaviorActionImplementations["delete backward"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "delete text": {
+                  behaviorActionImplementations["delete text"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "insert break": {
+                  behaviorActionImplementations["insert break"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "insert soft break": {
+                  behaviorActionImplementations["insert soft break"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "insert text": {
+                  behaviorActionImplementations["insert text"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "insert text block": {
+                  behaviorActionImplementations["insert text block"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "set block": {
+                  behaviorActionImplementations["set block"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "unset block": {
+                  behaviorActionImplementations["unset block"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                default:
+                  behaviorActionImplementations.effect({
+                    context,
+                    action
+                  });
+              }
+            }
+          }), event.editor.onChange();
+        }
+      ]
     }
   },
   initial: "pristine",