@portabletext/editor 1.1.4 → 1.1.6

package/lib/index.esm.js

@@ -5,23 +5,23 @@ import { useRef, useState, useMemo, useEffect, useCallback, createContext, useCo
 import { Editor, Element as Element$1, Range, Point, Text, Path, Transforms, Node, Operation, createEditor } from "slate";
 import { useSlateStatic, ReactEditor, useSelected, withReact, Slate, useSlate, Editable } from "slate-react";
 import debug$m from "debug";
-import { isKeySegment, isPortableTextSpan as isPortableTextSpan$1, isPortableTextTextBlock, isPortableTextListBlock } from "@sanity/types";
+import { isKeySegment, isPortableTextTextBlock, isPortableTextSpan, isPortableTextListBlock } from "@sanity/types";
 import { styled } from "styled-components";
 import uniq from "lodash/uniq.js";
 import { Subject } from "rxjs";
-import { fromCallback, setup, emit, assertEvent, assign, enqueueActions, createActor } from "xstate";
+import { fromCallback, setup, assertEvent, assign, emit, enqueueActions, createActor } from "xstate";
 import { Schema } from "@sanity/schema";
+import { isHotkey } from "is-hotkey-esm";
 import { diffMatchPatch as diffMatchPatch$1, set, insert, setIfMissing, unset, applyAll } from "@portabletext/patches";
 import get from "lodash/get.js";
 import isUndefined from "lodash/isUndefined.js";
 import omitBy from "lodash/omitBy.js";
 import flatten from "lodash/flatten.js";
-import { isHotkey } from "is-hotkey-esm";
 import { htmlToBlocks, normalizeBlock } from "@sanity/block-tools";
 import isPlainObject from "lodash/isPlainObject.js";
 import throttle from "lodash/throttle.js";
-import { randomKey } from "@sanity/util/content";
 import debounce from "lodash/debounce.js";
+import { randomKey } from "@sanity/util/content";
 const rootName = "sanity-pte:";
 debug$m(rootName);
 function debugWithName(name) {
@@ -808,7 +808,28 @@ function compileType(rawType) {
     types: [rawType]
   }).get(rawType.name);
 }
-const debug$k = debugWithName("operationToPatches");
+function getFocusBlock(context) {
+  const key = context.selection && isKeySegment(context.selection.focus.path[0]) ? context.selection.focus.path[0]._key : void 0, node = key ? context.value.find((block) => block._key === key) : void 0;
+  return node && key ? { node, path: [{ _key: key }] } : void 0;
+}
+function getFocusBlockObject(context) {
+  const focusBlock = getFocusBlock(context);
+  return focusBlock && !isPortableTextTextBlock(focusBlock.node) ? { node: focusBlock.node, path: focusBlock.path } : void 0;
+}
+const overwriteSoftReturn = {
+  on: "key down",
+  guard: ({ event }) => isHotkey("shift+enter", event.nativeEvent),
+  actions: [
+    ({ event }) => (event.nativeEvent.preventDefault(), { type: "insert text", text: `
+` })
+  ]
+}, enterOnVoidBlock = {
+  on: "key down",
+  guard: ({ context, event }) => isHotkey("enter", event.nativeEvent) ? !!getFocusBlockObject(context) : !1,
+  actions: [
+    ({ event }) => (event.nativeEvent.preventDefault(), { type: "insert text block", decorators: [] })
+  ]
+}, coreBehaviors = [overwriteSoftReturn, enterOnVoidBlock], debug$k = debugWithName("operationToPatches");
 function createOperationToPatches(types) {
   const textBlockName = types.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
@@ -1084,7 +1105,7 @@ function createOperationToPatches(types) {
   };
 }
 const debug$j = debugWithName("API:editable");
-function createWithEditableAPI(portableTextEditor, types, keyGenerator) {
+function createWithEditableAPI(editorActor, portableTextEditor, types) {
   return function(editor) {
     return portableTextEditor.setEditable({
       focus: () => {
@@ -1164,11 +1185,11 @@ function createWithEditableAPI(portableTextEditor, types, keyGenerator) {
         const child = toSlateValue(
           [
             {
-              _key: keyGenerator(),
+              _key: editorActor.getSnapshot().context.keyGenerator(),
               _type: types.block.name,
               children: [
                 {
-                  _key: keyGenerator(),
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
                   _type: type.name,
                   ...value || {}
                 }
@@ -1196,7 +1217,7 @@ function createWithEditableAPI(portableTextEditor, types, keyGenerator) {
         const block = toSlateValue(
           [
             {
-              _key: keyGenerator(),
+              _key: editorActor.getSnapshot().context.keyGenerator(),
               _type: type.name,
               ...value || {}
             }
@@ -1329,14 +1350,14 @@ function createWithEditableAPI(portableTextEditor, types, keyGenerator) {
             })
           ];
           if (spans.length === 0 || spans.some(
-            ([span]) => !isPortableTextSpan$1(span) || !span.marks || span.marks?.length === 0
+            ([span]) => !isPortableTextSpan(span) || !span.marks || span.marks?.length === 0
           ))
             return !1;
           const selectionMarkDefs = spans.reduce((accMarkDefs, [, path]) => {
             const [block] = Editor.node(editor, path, { depth: 1 });
             return editor.isTextBlock(block) && block.markDefs ? [...accMarkDefs, ...block.markDefs] : accMarkDefs;
           }, []);
-          return spans.every(([span]) => isPortableTextSpan$1(span) ? span.marks?.map(
+          return spans.every(([span]) => isPortableTextSpan(span) ? span.marks?.map(
             (markKey) => selectionMarkDefs.find((def) => def?._key === markKey)?._type
           )?.includes(annotationType) : !1);
         } catch {
@@ -1360,7 +1381,7 @@ function createWithEditableAPI(portableTextEditor, types, keyGenerator) {
             for (const [block, blockPath] of selectedBlocks) {
               if (block.children.length === 0 || block.children.length === 1 && block.children[0].text === "")
                 continue;
-              const annotationKey = keyGenerator(), markDefs = block.markDefs ?? [];
+              const annotationKey = editorActor.getSnapshot().context.keyGenerator(), markDefs = block.markDefs ?? [];
               markDefs.find(
                 (markDef) => markDef._type === type.name && markDef._key === annotationKey
               ) === void 0 && (Transforms.setNodes(
@@ -1569,7 +1590,7 @@ function createWithEditableAPI(portableTextEditor, types, keyGenerator) {
     }), editor;
   };
 }
-function createWithInsertBreak(types, keyGenerator) {
+function createWithInsertBreak(editorActor, types) {
   return function(editor) {
     const { insertBreak } = editor;
     return editor.insertBreak = () => {
@@ -1658,7 +1679,10 @@ function createWithInsertBreak(types, keyGenerator) {
                     (decorator) => decorator.value === mark
                   ) || prevNodeSpans.some(
                     (prevNodeSpan) => prevNodeSpan.marks?.includes(mark)
-                  ) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
+                  ) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(
+                    mark,
+                    editorActor.getSnapshot().context.keyGenerator()
+                  );
                 const newMarks = marks.map(
                   (mark) => newMarkDefKeys.get(mark) ?? mark
                 );
@@ -1739,7 +1763,7 @@ function createWithMaxBlocks(maxBlocks) {
     }, editor;
   };
 }
-function createWithObjectKeys(editorActor, schemaTypes, keyGenerator) {
+function createWithObjectKeys(editorActor, schemaTypes) {
   return function(editor) {
     const { apply: apply2, normalizeNode } = editor;
     return editor.apply = (operation) => {
@@ -1756,7 +1780,7 @@ function createWithObjectKeys(editorActor, schemaTypes, keyGenerator) {
           ...operation,
           properties: {
             ...operation.properties,
-            _key: keyGenerator()
+            _key: editorActor.getSnapshot().context.keyGenerator()
           }
         });
         return;
@@ -1766,7 +1790,7 @@ function createWithObjectKeys(editorActor, schemaTypes, keyGenerator) {
           ...operation,
           node: {
             ...operation.node,
-            _key: keyGenerator()
+            _key: editorActor.getSnapshot().context.keyGenerator()
           }
         });
         return;
@@ -1776,12 +1800,20 @@ function createWithObjectKeys(editorActor, schemaTypes, keyGenerator) {
       const [node, path] = entry;
       if (Element$1.isElement(node) && node._type === schemaTypes.block.name) {
         if (!node._key) {
-          editorActor.send({ type: "normalizing" }), Transforms.setNodes(editor, { _key: keyGenerator() }, { at: path }), editorActor.send({ type: "done normalizing" });
+          editorActor.send({ type: "normalizing" }), Transforms.setNodes(
+            editor,
+            { _key: editorActor.getSnapshot().context.keyGenerator() },
+            { at: path }
+          ), editorActor.send({ type: "done normalizing" });
           return;
         }
         for (const [child, childPath] of Node.children(editor, path))
           if (!child._key) {
-            editorActor.send({ type: "normalizing" }), Transforms.setNodes(editor, { _key: keyGenerator() }, { at: childPath }), editorActor.send({ type: "done normalizing" });
+            editorActor.send({ type: "normalizing" }), Transforms.setNodes(
+              editor,
+              { _key: editorActor.getSnapshot().context.keyGenerator() },
+              { at: childPath }
+            ), editorActor.send({ type: "done normalizing" });
             return;
           }
       }
@@ -3257,9 +3289,6 @@ function createWithPortableTextLists(types) {
     }, editor;
   };
 }
-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"));
-}
 function isPortableTextBlock(node) {
   return (
     // A block doesn't _have_ to be named 'block' - to differentiate between
@@ -3272,8 +3301,36 @@ function isPortableTextBlock(node) {
     node.children.every((child) => typeof child == "object" && "_type" in child)
   );
 }
+function getPreviousSpan({
+  editor,
+  blockPath,
+  spanPath
+}) {
+  let previousSpan;
+  for (const [child, childPath] of Node.children(editor, blockPath, {
+    reverse: !0
+  }))
+    if (editor.isTextSpan(child) && Path.isBefore(childPath, spanPath)) {
+      previousSpan = child;
+      break;
+    }
+  return previousSpan;
+}
+function getNextSpan({
+  editor,
+  blockPath,
+  spanPath
+}) {
+  let nextSpan;
+  for (const [child, childPath] of Node.children(editor, blockPath))
+    if (editor.isTextSpan(child) && Path.isAfter(childPath, spanPath)) {
+      nextSpan = child;
+      break;
+    }
+  return nextSpan;
+}
 const debug$c = debugWithName("plugin:withPortableTextMarkModel");
-function createWithPortableTextMarkModel(editorActor, types, keyGenerator) {
+function createWithPortableTextMarkModel(editorActor, types) {
   return function(editor) {
     const { apply: apply2, normalizeNode } = editor, decorators = types.decorators.map((t) => t.value), forceNewSelection = () => {
       editor.selection && (Transforms.select(editor, { ...editor.selection }), editor.selection = { ...editor.selection });
@@ -3411,98 +3468,85 @@ function createWithPortableTextMarkModel(editorActor, types, keyGenerator) {
             })
           )[0] ?? [void 0, void 0], marks = span.marks ?? [], marksWithoutAnnotations = marks.filter(
             (mark) => decorators.includes(mark)
-          ), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length;
-          let previousSpan, nextSpan;
-          for (const [child, childPath] of Node.children(editor, blockPath, {
-            reverse: !0
-          }))
-            if (editor.isTextSpan(child) && Path.isBefore(childPath, spanPath)) {
-              previousSpan = child;
-              break;
-            }
-          for (const [child, childPath] of Node.children(editor, blockPath))
-            if (editor.isTextSpan(child) && Path.isAfter(childPath, spanPath)) {
-              nextSpan = child;
-              break;
-            }
-          const previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some(
+          ), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length, previousSpan = getPreviousSpan({ editor, blockPath, spanPath }), nextSpan = getNextSpan({ editor, blockPath, spanPath }), nextSpanAnnotations = nextSpan?.marks?.filter((mark) => !decorators.includes(mark)) ?? [], spanAnnotations = marks.filter(
+            (mark) => !decorators.includes(mark)
+          ), previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some(
             (mark) => !decorators.includes(mark) && marks.includes(mark)
-          ) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? nextSpan.marks?.some(
-            (mark) => !decorators.includes(mark) && marks.includes(mark)
-          ) : !1, nextSpanHasSameMarks = nextSpan ? nextSpan.marks?.every((mark) => marks.includes(mark)) : !1;
+          ) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some(
+            (mark) => nextSpanAnnotations?.includes(mark)
+          );
           if (spanHasAnnotations && !spanIsEmpty) {
             if (atTheBeginningOfSpan) {
               previousSpanHasSameMarks ? Transforms.insertNodes(editor, {
                 _type: "span",
-                _key: keyGenerator(),
+                _key: editorActor.getSnapshot().context.keyGenerator(),
                 text: op.text,
                 marks: previousSpan?.marks ?? []
               }) : previousSpanHasSameAnnotation ? apply2(op) : Transforms.insertNodes(editor, {
                 _type: "span",
-                _key: keyGenerator(),
+                _key: editorActor.getSnapshot().context.keyGenerator(),
                 text: op.text,
                 marks: []
               });
               return;
             }
             if (atTheEndOfSpan) {
-              nextSpanHasSameMarks ? Transforms.insertNodes(editor, {
-                _type: "span",
-                _key: keyGenerator(),
-                text: op.text,
-                marks: nextSpan?.marks ?? []
-              }) : nextSpanHasSameAnnotation ? apply2(op) : Transforms.insertNodes(editor, {
-                _type: "span",
-                _key: keyGenerator(),
-                text: op.text,
-                marks: []
-              });
-              return;
+              if (nextSpan && nextSpanSharesSomeAnnotations && nextSpanAnnotations.length < spanAnnotations.length || !nextSpanSharesSomeAnnotations) {
+                Transforms.insertNodes(editor, {
+                  _type: "span",
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
+                  text: op.text,
+                  marks: nextSpan?.marks ?? []
+                });
+                return;
+              }
+              if (!nextSpan) {
+                Transforms.insertNodes(editor, {
+                  _type: "span",
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
+                  text: op.text,
+                  marks: []
+                });
+                return;
+              }
             }
           }
         }
       }
       if (op.type === "remove_text") {
-        const node = Array.from(
-          Editor.nodes(editor, {
-            mode: "lowest",
-            at: { path: op.path, offset: op.offset },
-            match: (n) => n._type === types.span.name,
-            voids: !1
-          })
-        )[0][0], block = Editor.node(editor, Path.parent(op.path))[0];
-        if (node && isPortableTextSpan(node) && block && isPortableTextBlock(block)) {
-          const markDefs = block.markDefs ?? [], nodeHasAnnotations = (node.marks ?? []).some(
-            (mark) => markDefs.find((markDef) => markDef._key === mark)
-          ), deletingPartOfTheNode = op.offset !== 0, deletingFromTheEnd = op.offset + op.text.length === node.text.length;
-          if (nodeHasAnnotations && deletingPartOfTheNode && deletingFromTheEnd) {
-            Editor.withoutNormalizing(editor, () => {
-              Transforms.splitNodes(editor, {
-                match: Text.isText,
-                at: { path: op.path, offset: op.offset }
-              }), Transforms.removeNodes(editor, { at: Path.next(op.path) });
-            }), editor.onChange();
-            return;
-          }
-          const deletingAllText = op.offset === 0 && deletingFromTheEnd;
-          if (nodeHasAnnotations && deletingAllText) {
-            const marksWithoutAnnotationMarks = ({
-              ...Editor.marks(editor) || {}
-            }.marks || []).filter((mark) => decorators.includes(mark));
-            Editor.withoutNormalizing(editor, () => {
-              apply2(op), Transforms.setNodes(
-                editor,
-                { marks: marksWithoutAnnotationMarks },
-                { at: op.path }
-              );
-            }), editor.onChange();
-            return;
-          }
-          if (node.marks !== void 0 && node.marks.length > 0 && deletingAllText) {
-            Editor.withoutNormalizing(editor, () => {
-              apply2(op), Transforms.setNodes(editor, { marks: [] }, { at: op.path });
-            }), editor.onChange();
-            return;
+        const { selection } = editor;
+        if (selection && Range.isExpanded(selection)) {
+          const [block, blockPath] = Editor.node(editor, selection, {
+            depth: 1
+          }), [span, spanPath] = Array.from(
+            Editor.nodes(editor, {
+              mode: "lowest",
+              at: { path: op.path, offset: op.offset },
+              match: (n) => editor.isTextSpan(n),
+              voids: !1
+            })
+          )[0] ?? [void 0, void 0];
+          if (span && block && isPortableTextBlock(block)) {
+            const markDefs = block.markDefs ?? [], marks = span.marks ?? [], spanHasAnnotations = marks.some(
+              (mark) => markDefs.find((markDef) => markDef._key === mark)
+            ), deletingFromTheEnd = op.offset + op.text.length === span.text.length, deletingAllText = op.offset === 0 && deletingFromTheEnd, previousSpan = getPreviousSpan({ editor, blockPath, spanPath }), nextSpan = getNextSpan({ editor, blockPath, spanPath }), previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some(
+              (mark) => !decorators.includes(mark) && marks.includes(mark)
+            ) : !1, nextSpanHasSameAnnotation = nextSpan ? nextSpan.marks?.some(
+              (mark) => !decorators.includes(mark) && marks.includes(mark)
+            ) : !1;
+            if (spanHasAnnotations && deletingAllText && !previousSpanHasSameAnnotation && !nextSpanHasSameAnnotation) {
+              const marksWithoutAnnotationMarks = ({
+                ...Editor.marks(editor) || {}
+              }.marks || []).filter((mark) => decorators.includes(mark));
+              Editor.withoutNormalizing(editor, () => {
+                apply2(op), Transforms.setNodes(
+                  editor,
+                  { marks: marksWithoutAnnotationMarks },
+                  { at: op.path }
+                );
+              }), editor.onChange();
+              return;
+            }
           }
         }
       }
@@ -3686,17 +3730,16 @@ function createWithPortableTextSelections(editorActor, types) {
 const debug$a = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   editorActor,
-  schemaTypes,
-  keyGenerator
+  schemaTypes
 }) {
   return function(editor) {
-    editor.isTextBlock = (value) => isPortableTextTextBlock(value) && value._type === schemaTypes.block.name, editor.isTextSpan = (value) => isPortableTextSpan$1(value) && value._type === schemaTypes.span.name, editor.isListBlock = (value) => isPortableTextListBlock(value) && value._type === schemaTypes.block.name, editor.isVoid = (element) => schemaTypes.block.name !== element._type && (schemaTypes.blockObjects.map((obj) => obj.name).includes(element._type) || schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type)), editor.isInline = (element) => schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type) && "__inline" in element && element.__inline === !0;
+    editor.isTextBlock = (value) => isPortableTextTextBlock(value) && value._type === schemaTypes.block.name, editor.isTextSpan = (value) => isPortableTextSpan(value) && value._type === schemaTypes.span.name, editor.isListBlock = (value) => isPortableTextListBlock(value) && value._type === schemaTypes.block.name, editor.isVoid = (element) => schemaTypes.block.name !== element._type && (schemaTypes.blockObjects.map((obj) => obj.name).includes(element._type) || schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type)), editor.isInline = (element) => schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type) && "__inline" in element && element.__inline === !0;
     const { normalizeNode } = editor;
     return editor.normalizeNode = (entry) => {
       const [node, path] = entry;
       if (node._type === void 0 && path.length === 2) {
         debug$a("Setting span type on text node without a type");
-        const span = node, key = span._key || keyGenerator();
+        const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({ type: "normalizing" }), Transforms.setNodes(
           editor,
           { ...span, _type: schemaTypes.span.name, _key: key },
@@ -3706,7 +3749,7 @@ function createWithSchemaTypes({
       }
       if (node._key === void 0 && (path.length === 1 || path.length === 2)) {
         debug$a("Setting missing key on child node without a key");
-        const key = keyGenerator();
+        const key = editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({ type: "normalizing" }), Transforms.setNodes(editor, { _key: key }, { at: path }), editorActor.send({ type: "done normalizing" });
         return;
       }
@@ -3716,8 +3759,8 @@ function createWithSchemaTypes({
 }
 const debug$9 = debugWithName("plugin:withUtils");
 function createWithUtils({
+  editorActor,
   schemaTypes,
-  keyGenerator,
   portableTextEditor
 }) {
   return function(editor) {
@@ -3743,13 +3786,13 @@ function createWithUtils({
       [
         {
           _type: schemaTypes.block.name,
-          _key: keyGenerator(),
+          _key: editorActor.getSnapshot().context.keyGenerator(),
           style: schemaTypes.styles[0].value || "normal",
           markDefs: [],
           children: [
             {
               _type: "span",
-              _key: keyGenerator(),
+              _key: editorActor.getSnapshot().context.keyGenerator(),
               text: "",
               marks: options.decorators.filter(
                 (decorator) => schemaTypes.decorators.find(({ value }) => value === decorator)
@@ -3817,7 +3860,7 @@ function createWithHotkeys(types, portableTextEditor, hotkeysFromOptions) {
               {
                 at: nextPath
               }
-            ), editor.onChange();
+            ), Transforms.select(editor, { path: [...nextPath, 0], offset: 0 }), editor.onChange();
             return;
           }
         }
@@ -3841,10 +3884,10 @@ function createWithHotkeys(types, portableTextEditor, hotkeysFromOptions) {
       if ((isTab || isShiftTab) && editor.selection) {
         const [focusChild] = Editor.node(editor, editor.selection.focus, {
           depth: 2
-        }), [focusBlock] = isPortableTextSpan$1(focusChild) ? Editor.node(editor, editor.selection.focus, { depth: 1 }) : [], hasAnnotationFocus = focusChild && isPortableTextTextBlock(focusBlock) && isPortableTextSpan$1(focusChild) && (focusChild.marks || []).filter(
+        }), [focusBlock] = isPortableTextSpan(focusChild) ? Editor.node(editor, editor.selection.focus, { depth: 1 }) : [], hasAnnotationFocus = focusChild && isPortableTextTextBlock(focusBlock) && isPortableTextSpan(focusChild) && (focusChild.marks || []).filter(
           (m) => (focusBlock.markDefs || []).map((def) => def._key).includes(m)
         ).length > 0, [start] = Range.edges(editor.selection), atStartOfNode = Editor.isStart(editor, start, start.path);
-        focusChild && isPortableTextSpan$1(focusChild) && (!hasAnnotationFocus || atStartOfNode) && editor.pteIncrementBlockLevels(isShiftTab) && event.preventDefault();
+        focusChild && isPortableTextSpan(focusChild) && (!hasAnnotationFocus || atStartOfNode) && editor.pteIncrementBlockLevels(isShiftTab) && event.preventDefault();
       }
       if (isEnter && !isShiftEnter && editor.selection) {
         const focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
@@ -3862,22 +3905,7 @@ function createWithHotkeys(types, portableTextEditor, hotkeysFromOptions) {
             return;
           }
         }
-        if (focusBlock && Editor.isVoid(editor, focusBlock)) {
-          Editor.insertNode(editor, editor.pteCreateTextBlock({ decorators: [] })), event.preventDefault(), editor.onChange();
-          return;
-        }
-        event.preventDefault(), editor.insertBreak(), editor.onChange();
-      }
-      if (isShiftEnter) {
-        event.preventDefault(), editor.insertText(`
-`);
-        return;
       }
-      if (isHotkey("mod+z", event.nativeEvent)) {
-        event.preventDefault(), editor.undo();
-        return;
-      }
-      (isHotkey("mod+y", event.nativeEvent) || isHotkey("mod+shift+z", event.nativeEvent)) && (event.preventDefault(), editor.redo());
     }, editor;
   };
 }
@@ -4160,7 +4188,7 @@ function validateValue(value, types, keyGenerator) {
   }) && (valid = !1), { valid, resolution, value });
 }
 const debug$7 = debugWithName("plugin:withInsertData");
-function createWithInsertData(editorActor, schemaTypes, keyGenerator) {
+function createWithInsertData(editorActor, schemaTypes) {
   return function(editor) {
     const blockTypeName = schemaTypes.block.name, spanTypeName = schemaTypes.span.name, whitespaceOnPasteMode = schemaTypes.block.options.unstable_whitespaceOnPasteMode, toPlainText = (blocks) => blocks.map((block) => editor.isTextBlock(block) ? block.children.map((child) => child._type === spanTypeName ? child.text : `[${schemaTypes.inlineObjects.find((t) => t.name === child._type)?.title || "Object"}]`).join("") : `[${schemaTypes.blockObjects.find((t) => t.name === block._type)?.title || "Object"}]`).join(`
 
@@ -4208,10 +4236,14 @@ function createWithInsertData(editorActor, schemaTypes, keyGenerator) {
           const slateValue = _regenerateKeys(
             editor,
             toSlateValue(parsed, { schemaTypes }),
-            keyGenerator,
+            editorActor.getSnapshot().context.keyGenerator,
             spanTypeName,
             schemaTypes
-          ), validation = validateValue(parsed, schemaTypes, keyGenerator);
+          ), validation = validateValue(
+            parsed,
+            schemaTypes,
+            editorActor.getSnapshot().context.keyGenerator
+          );
           if (!validation.valid && !validation.resolution?.autoResolve) {
             const errorDescription = `${validation.resolution?.description}`;
             return editorActor.send({
@@ -4252,7 +4284,7 @@ function createWithInsertData(editorActor, schemaTypes, keyGenerator) {
         const validation = validateValue(
           portableText,
           schemaTypes,
-          keyGenerator
+          editorActor.getSnapshot().context.keyGenerator
         );
         if (!validation.valid) {
           const errorDescription = `Could not validate the resulting portable text to insert.
@@ -4356,27 +4388,21 @@ function _insertFragment(editor, fragment, schemaTypes) {
   }), editor.onChange();
 }
 const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, options) => {
-  const e = editor, { keyGenerator, portableTextEditor, patches$, readOnly, maxBlocks } = options, { editorActor, schemaTypes } = portableTextEditor;
+  const e = editor, { portableTextEditor, patches$, readOnly, maxBlocks } = options, { editorActor, schemaTypes } = portableTextEditor;
   e.subscriptions = [], e.destroy ? e.destroy() : originalFnMap.set(e, {
     apply: e.apply,
     onChange: e.onChange,
     normalizeNode: e.normalizeNode
   });
-  const operationToPatches = createOperationToPatches(schemaTypes), withObjectKeys = createWithObjectKeys(
+  const operationToPatches = createOperationToPatches(schemaTypes), withObjectKeys = createWithObjectKeys(editorActor, schemaTypes), withSchemaTypes = createWithSchemaTypes({
     editorActor,
-    schemaTypes,
-    keyGenerator
-  ), withSchemaTypes = createWithSchemaTypes({
-    editorActor,
-    schemaTypes,
-    keyGenerator
+    schemaTypes
   }), withEditableAPI = createWithEditableAPI(
+    editorActor,
     portableTextEditor,
-    schemaTypes,
-    keyGenerator
+    schemaTypes
   ), withPatches = createWithPatches({
     editorActor,
-    keyGenerator,
     patches$,
     patchFunctions: operationToPatches,
     readOnly,
@@ -4387,13 +4413,12 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
     blockSchemaType: schemaTypes.block
   }), withPortableTextMarkModel = createWithPortableTextMarkModel(
     editorActor,
-    schemaTypes,
-    keyGenerator
+    schemaTypes
   ), withPortableTextBlockStyle = createWithPortableTextBlockStyle(
     editorActor,
     schemaTypes
-  ), withPlaceholderBlock = createWithPlaceholderBlock(), withInsertBreak = createWithInsertBreak(schemaTypes, keyGenerator), withUtils = createWithUtils({
-    keyGenerator,
+  ), withPlaceholderBlock = createWithPlaceholderBlock(), withInsertBreak = createWithInsertBreak(editorActor, schemaTypes), withUtils = createWithUtils({
+    editorActor,
     schemaTypes,
     portableTextEditor
   }), withPortableTextSelections = createWithPortableTextSelections(
@@ -4461,10 +4486,9 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
   };
 }, debug$6 = debugWithName("component:PortableTextEditor:SlateContainer");
 function SlateContainer(props) {
-  const { patches$, portableTextEditor, readOnly, maxBlocks, keyGenerator } = props, [[slateEditor, subscribe]] = useState(() => {
+  const { patches$, portableTextEditor, readOnly, maxBlocks } = props, [[slateEditor, subscribe]] = useState(() => {
     debug$6("Creating new Slate editor instance");
     const { editor, subscribe: _sub } = withPlugins(withReact(createEditor()), {
-      keyGenerator,
       maxBlocks,
       patches$,
       portableTextEditor,
@@ -4479,33 +4503,18 @@ function SlateContainer(props) {
     };
   }, [subscribe]), useEffect(() => {
     debug$6("Re-initializing plugin chain"), withPlugins(slateEditor, {
-      keyGenerator,
       maxBlocks,
       patches$,
       portableTextEditor,
       readOnly
     });
-  }, [
-    keyGenerator,
-    portableTextEditor,
-    maxBlocks,
-    readOnly,
-    patches$,
-    slateEditor
-  ]);
+  }, [portableTextEditor, maxBlocks, readOnly, patches$, slateEditor]);
   const initialValue = useMemo(() => [slateEditor.pteCreateTextBlock({ decorators: [] })], [slateEditor]);
   return useEffect(() => () => {
     debug$6("Destroying Slate editor"), slateEditor.destroy();
   }, [slateEditor]), /* @__PURE__ */ jsx(Slate, { editor: slateEditor, initialValue, children: props.children });
 }
-const defaultKeyGenerator = () => randomKey(12), PortableTextEditorKeyGeneratorContext = createContext(defaultKeyGenerator), usePortableTextEditorKeyGenerator = () => {
-  const keyGenerator = useContext(PortableTextEditorKeyGeneratorContext);
-  if (keyGenerator === void 0)
-    throw new Error(
-      "The `usePortableTextEditorKeyGenerator` hook must be used inside the <PortableTextEditor> component's context."
-    );
-  return keyGenerator;
-}, PortableTextEditorReadOnlyContext = createContext(!1), usePortableTextEditorReadOnlyStatus = () => {
+const PortableTextEditorReadOnlyContext = createContext(!1), usePortableTextEditorReadOnlyStatus = () => {
   const readOnly = useContext(PortableTextEditorReadOnlyContext);
   if (readOnly === void 0)
     throw new Error(
@@ -4514,7 +4523,7 @@ const defaultKeyGenerator = () => randomKey(12), PortableTextEditorKeyGeneratorC
   return readOnly;
 }, debug$5 = debugWithName("hook:useSyncValue"), CURRENT_VALUE = /* @__PURE__ */ new WeakMap();
 function useSyncValue(props) {
-  const { editorActor, portableTextEditor, readOnly, keyGenerator } = props, { schemaTypes } = portableTextEditor, previousValue = useRef(), slateEditor = useSlate(), updateValueFunctionRef = useRef(), updateFromCurrentValue = useCallback(() => {
+  const { editorActor, portableTextEditor, readOnly } = props, { schemaTypes } = portableTextEditor, previousValue = useRef(), slateEditor = useSlate(), updateValueFunctionRef = useRef(), updateFromCurrentValue = useCallback(() => {
     const currentValue = CURRENT_VALUE.get(portableTextEditor);
     if (previousValue.current === currentValue) {
       debug$5("Value is the same object as previous, not need to sync");
@@ -4580,7 +4589,7 @@ function useSyncValue(props) {
                       const validationValue = [value[currentBlockIndex]], validation = validateValue(
                         validationValue,
                         schemaTypes,
-                        keyGenerator
+                        editorActor.getSnapshot().context.keyGenerator
                       );
                       !validation.valid && validation.resolution?.autoResolve && validation.resolution?.patches.length > 0 && !readOnly && previousValue.current && previousValue.current !== value && (console.warn(
                         `${validation.resolution.action} for block with _key '${validationValue[0]._key}'. ${validation.resolution?.description}`
@@ -4605,7 +4614,7 @@ function useSyncValue(props) {
                       const validationValue = [value[currentBlockIndex]], validation = validateValue(
                         validationValue,
                         schemaTypes,
-                        keyGenerator
+                        editorActor.getSnapshot().context.keyGenerator
                       );
                       debug$5.enabled && debug$5(
                         "Validating and inserting new block in the end of the value",
@@ -4652,7 +4661,6 @@ function useSyncValue(props) {
     return updateValueFunctionRef.current = updateFunction, updateFunction;
   }, [
     editorActor,
-    keyGenerator,
     portableTextEditor,
     readOnly,
     schemaTypes,
@@ -4720,9 +4728,8 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
 }
 const debug$4 = debugWithName("component:PortableTextEditor:Synchronizer"), debugVerbose$1 = debug$4.enabled && !1, FLUSH_PATCHES_THROTTLED_MS = process.env.NODE_ENV === "test" ? 500 : 1e3;
 function Synchronizer(props) {
-  const portableTextEditor = usePortableTextEditor(), keyGenerator = usePortableTextEditorKeyGenerator(), readOnly = usePortableTextEditorReadOnlyStatus(), { editorActor, getValue, onChange, value } = props, pendingPatches = useRef([]), syncValue = useSyncValue({
+  const portableTextEditor = usePortableTextEditor(), readOnly = usePortableTextEditorReadOnlyStatus(), { editorActor, getValue, onChange, value } = props, pendingPatches = useRef([]), syncValue = useSyncValue({
     editorActor,
-    keyGenerator,
     portableTextEditor,
     readOnly
   }), slateEditor = useSlate();
@@ -4823,6 +4830,29 @@ ${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;
 }
+function inserText({
+  event
+}) {
+  Editor.insertText(event.editor, event.text);
+}
+function inserTextBlock({
+  context,
+  event
+}) {
+  Editor.insertNode(event.editor, {
+    _key: context.keyGenerator(),
+    _type: context.schema.block.name,
+    style: context.schema.styles[0].value ?? "normal",
+    markDefs: [],
+    children: [
+      {
+        _key: context.keyGenerator(),
+        _type: "span",
+        text: ""
+      }
+    ]
+  });
+}
 const networkLogic = fromCallback(({ sendBack }) => {
   const onlineHandler = () => {
     sendBack({ type: "online" });
@@ -4836,9 +4866,19 @@ const networkLogic = fromCallback(({ sendBack }) => {
   types: {
     context: {},
     events: {},
-    emitted: {}
+    emitted: {},
+    input: {}
   },
   actions: {
+    "apply:insert text": ({ context, event }) => {
+      assertEvent(event, "insert text"), inserText({ context, event });
+    },
+    "apply:insert text block": ({ context, event }) => {
+      assertEvent(event, "insert text block"), inserTextBlock({ context, event });
+    },
+    "assign schema": assign({
+      schema: ({ event }) => (assertEvent(event, "update schema"), event.schema)
+    }),
     "emit patch event": emit(({ event }) => (assertEvent(event, "patch"), event)),
     "emit mutation event": emit(({ event }) => (assertEvent(event, "mutation"), event)),
     "defer event": assign({
@@ -4850,6 +4890,50 @@ const networkLogic = fromCallback(({ sendBack }) => {
     }),
     "clear pending events": assign({
       pendingEvents: []
+    }),
+    "handle behavior event": enqueueActions(({ context, event, enqueue }) => {
+      assertEvent(event, ["key down"]);
+      const eventBehaviors = context.behaviors.filter(
+        (behavior) => behavior.on === event.type
+      );
+      if (eventBehaviors.length === 0)
+        return;
+      const value = fromSlateValue(
+        event.editor.children,
+        context.schema.block.name,
+        KEY_TO_VALUE_ELEMENT.get(event.editor)
+      ), selection = toPortableTextRange(
+        value,
+        event.editor.selection,
+        context.schema
+      );
+      if (!selection) {
+        console.warn(
+          `Unable to handle event ${event.type} due to missing selection`
+        );
+        return;
+      }
+      const behaviorContext = {
+        schema: context.schema,
+        value,
+        selection
+      };
+      for (const eventBehavior of eventBehaviors) {
+        const shouldRun = eventBehavior.guard?.({
+          context: behaviorContext,
+          event
+        }) ?? !0;
+        if (!shouldRun)
+          continue;
+        const actions = eventBehavior.actions.map(
+          (action) => action({ context: behaviorContext, event }, shouldRun)
+        );
+        for (const action of actions)
+          typeof action == "object" && enqueue.raise({
+            ...action,
+            editor: event.editor
+          });
+      }
     })
   },
   actors: {
@@ -4857,9 +4941,12 @@ const networkLogic = fromCallback(({ sendBack }) => {
   }
 }).createMachine({
   id: "editor",
-  context: {
-    pendingEvents: []
-  },
+  context: ({ input }) => ({
+    behaviors: input.behaviors,
+    keyGenerator: input.keyGenerator,
+    pendingEvents: [],
+    schema: input.schema
+  }),
   invoke: {
     id: "networkLogic",
     src: "networkLogic"
@@ -4876,7 +4963,17 @@ const networkLogic = fromCallback(({ sendBack }) => {
     online: { actions: emit({ type: "online" }) },
     offline: { actions: emit({ type: "offline" }) },
     loading: { actions: emit({ type: "loading" }) },
-    "done loading": { actions: emit({ type: "done loading" }) }
+    "done loading": { actions: emit({ type: "done loading" }) },
+    "update schema": { actions: "assign schema" },
+    "key down": {
+      actions: ["handle behavior event"]
+    },
+    "insert text": {
+      actions: ["apply:insert text"]
+    },
+    "insert text block": {
+      actions: ["apply:insert text block"]
+    }
   },
   initial: "pristine",
   states: {
@@ -4947,7 +5044,7 @@ function PortableTextEditorSelectionProvider(props) {
     };
   }, [props.editorActor]), /* @__PURE__ */ jsx(PortableTextEditorSelectionContext.Provider, { value: selection, children: props.children });
 }
-const debug$2 = debugWithName("component:PortableTextEditor");
+const defaultKeyGenerator = () => randomKey(12), debug$2 = debugWithName("component:PortableTextEditor");
 class PortableTextEditor extends Component {
   /**
    * @internal
@@ -4971,14 +5068,23 @@ class PortableTextEditor extends Component {
       throw new Error('PortableTextEditor: missing "schemaType" property');
     props.incomingPatches$ && console.warn(
       "The prop 'incomingPatches$' is deprecated and renamed to 'patches$'"
-    ), this.editorActor = createActor(editorMachine), this.editorActor.start(), this.schemaTypes = getPortableTextMemberSchemaTypes(
+    ), this.schemaTypes = getPortableTextMemberSchemaTypes(
       props.schemaType.hasOwnProperty("jsonType") ? props.schemaType : compileType(props.schemaType)
-    );
+    ), this.editorActor = createActor(editorMachine, {
+      input: {
+        behaviors: coreBehaviors,
+        keyGenerator: props.keyGenerator || defaultKeyGenerator,
+        schema: this.schemaTypes
+      }
+    }), this.editorActor.start();
   }
   componentDidUpdate(prevProps) {
     this.props.schemaType !== prevProps.schemaType && (this.schemaTypes = getPortableTextMemberSchemaTypes(
       this.props.schemaType.hasOwnProperty("jsonType") ? this.props.schemaType : compileType(this.props.schemaType)
-    )), this.props.editorRef !== prevProps.editorRef && this.props.editorRef && (this.props.editorRef.current = this);
+    ), this.editorActor.send({
+      type: "update schema",
+      schema: this.schemaTypes
+    })), this.props.editorRef !== prevProps.editorRef && this.props.editorRef && (this.props.editorRef.current = this);
   }
   setEditable = (editable) => {
     this.editable = { ...this.editable, ...editable };
@@ -4988,35 +5094,28 @@ class PortableTextEditor extends Component {
       return this.editable.getValue();
   };
   render() {
-    const { value, children, patches$, incomingPatches$ } = this.props, _patches$ = incomingPatches$ || patches$, maxBlocks = typeof this.props.maxBlocks > "u" ? void 0 : Number.parseInt(this.props.maxBlocks.toString(), 10) || void 0, readOnly = !!this.props.readOnly, keyGenerator = this.props.keyGenerator || defaultKeyGenerator;
+    const { value, children, patches$, incomingPatches$ } = this.props, _patches$ = incomingPatches$ || patches$, maxBlocks = typeof this.props.maxBlocks > "u" ? void 0 : Number.parseInt(this.props.maxBlocks.toString(), 10) || void 0, readOnly = !!this.props.readOnly;
     return /* @__PURE__ */ jsx(
       SlateContainer,
       {
-        keyGenerator,
         maxBlocks,
         patches$: _patches$,
         portableTextEditor: this,
         readOnly,
-        children: /* @__PURE__ */ jsx(PortableTextEditorKeyGeneratorContext.Provider, { value: keyGenerator, children: /* @__PURE__ */ jsx(PortableTextEditorContext.Provider, { value: this, children: /* @__PURE__ */ jsx(PortableTextEditorReadOnlyContext.Provider, { value: readOnly, children: /* @__PURE__ */ jsxs(
-          PortableTextEditorSelectionProvider,
-          {
-            editorActor: this.editorActor,
-            children: [
-              /* @__PURE__ */ jsx(
-                Synchronizer,
-                {
-                  editorActor: this.editorActor,
-                  getValue: this.getValue,
-                  onChange: (change) => {
-                    this.props.onChange(change), this.change$.next(change);
-                  },
-                  value
-                }
-              ),
-              children
-            ]
-          }
-        ) }) }) })
+        children: /* @__PURE__ */ jsx(PortableTextEditorContext.Provider, { value: this, children: /* @__PURE__ */ jsx(PortableTextEditorReadOnlyContext.Provider, { value: readOnly, children: /* @__PURE__ */ jsxs(PortableTextEditorSelectionProvider, { editorActor: this.editorActor, children: [
+          /* @__PURE__ */ jsx(
+            Synchronizer,
+            {
+              editorActor: this.editorActor,
+              getValue: this.getValue,
+              onChange: (change) => {
+                this.props.onChange(change), this.change$.next(change);
+              },
+              value
+            }
+          ),
+          children
+        ] }) }) })
       }
     );
   }
@@ -5282,7 +5381,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     scrollSelectionIntoView,
     spellCheck,
     ...restProps
-  } = props, portableTextEditor = usePortableTextEditor(), readOnly = usePortableTextEditorReadOnlyStatus(), keyGenerator = usePortableTextEditorKeyGenerator(), ref = useRef(null), [editableElement, setEditableElement] = useState(
+  } = props, portableTextEditor = usePortableTextEditor(), readOnly = usePortableTextEditorReadOnlyStatus(), ref = useRef(null), [editableElement, setEditableElement] = useState(
     null
   ), [hasInvalidValue, setHasInvalidValue] = useState(!1), [rangeDecorationState, setRangeDecorationsState] = useState([]);
   useImperativeHandle(
@@ -5290,8 +5389,8 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     () => ref.current
   );
   const rangeDecorationsRef = useRef(rangeDecorations), { editorActor, schemaTypes } = portableTextEditor, slateEditor = useSlate(), blockTypeName = schemaTypes.block.name, withInsertData = useMemo(
-    () => createWithInsertData(editorActor, schemaTypes, keyGenerator),
-    [editorActor, keyGenerator, schemaTypes]
+    () => createWithInsertData(editorActor, schemaTypes),
+    [editorActor, schemaTypes]
   ), withHotKeys = useMemo(
     () => createWithHotkeys(schemaTypes, portableTextEditor, hotkeys),
     [hotkeys, portableTextEditor, schemaTypes]
@@ -5542,7 +5641,11 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
   }, [validateSelection, editableElement]);
   const handleKeyDown = useCallback(
     (event) => {
-      props.onKeyDown && props.onKeyDown(event), event.isDefaultPrevented() || slateEditor.pteWithHotKeys(event);
+      props.onKeyDown && props.onKeyDown(event), event.isDefaultPrevented() || (editorActor.send({
+        type: "key down",
+        nativeEvent: event.nativeEvent,
+        editor: slateEditor
+      }), slateEditor.pteWithHotKeys(event));
     },
     [props, slateEditor]
   ), scrollSelectionIntoViewToSlate = useMemo(() => {