@portabletext/editor 1.1.9 → 1.1.10

package/lib/index.esm.js

@@ -11,12 +11,12 @@ import uniq from "lodash/uniq.js";
 import { Subject } from "rxjs";
 import { fromCallback, setup, assign, assertEvent, 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";
@@ -816,20 +816,15 @@ 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");
+const softReturn = {
+  on: "insert soft break",
+  actions: [() => ({ type: "insert text", text: `
+` })]
+}, breakingVoidBlock = {
+  on: "insert break",
+  guard: ({ context }) => !!getFocusBlockObject(context),
+  actions: [() => ({ type: "insert text block", decorators: [] })]
+}, coreBehaviors = [softReturn, breakingVoidBlock], debug$k = debugWithName("operationToPatches");
 function createOperationToPatches(types) {
   const textBlockName = types.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
@@ -1104,6 +1099,50 @@ function createOperationToPatches(types) {
     splitNodePatch
   };
 }
+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)
+        },
+        editor
+      });
+    }, editor.insertBreak = () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert break",
+          default: insertBreak
+        },
+        editor
+      });
+    }, editor.insertSoftBreak = () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert soft break",
+          default: insertSoftBreak
+        },
+        editor
+      });
+    }, editor.insertText = (text, options) => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert text",
+          text,
+          default: () => insertText(text, options)
+        },
+        editor
+      });
+    }, editor;
+  };
+}
 const debug$j = debugWithName("API:editable");
 function createWithEditableAPI(editorActor, portableTextEditor, types) {
   return function(editor) {
@@ -1619,7 +1658,9 @@ function createWithInsertBreak(editorActor, types) {
           Editor.insertNode(
             editor,
             editor.pteCreateTextBlock({
-              decorators: focusAnnotations.length === 0 ? focusDecorators : []
+              decorators: focusAnnotations.length === 0 ? focusDecorators : [],
+              listItem: focusBlock.listItem,
+              level: focusBlock.level
             })
           );
           const [nextBlockPath] = Path.next(focusBlockPath);
@@ -1637,7 +1678,9 @@ function createWithInsertBreak(editorActor, types) {
           Editor.insertNode(
             editor,
             editor.pteCreateTextBlock({
-              decorators: []
+              decorators: [],
+              listItem: focusBlock.listItem,
+              level: focusBlock.level
             })
           );
           const [nextBlockPath] = Path.next(focusBlockPath);
@@ -3795,6 +3838,8 @@ function createWithUtils({
           _type: schemaTypes.block.name,
           _key: editorActor.getSnapshot().context.keyGenerator(),
           style: schemaTypes.styles[0].value || "normal",
+          ...options.listItem ? { listItem: options.listItem } : {},
+          ...options.level ? { level: options.level } : {},
           markDefs: [],
           children: [
             {
@@ -4421,7 +4466,7 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
   }), withPortableTextSelections = createWithPortableTextSelections(
     editorActor,
     schemaTypes
-  );
+  ), withEventListeners = createWithEventListeners(editorActor);
   return e.destroy = () => {
     const originalFunctions = originalFnMap.get(e);
     if (!originalFunctions)
@@ -4447,18 +4492,20 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
     ),
     subscribe: () => noop
   } : {
-    editor: withSchemaTypes(
-      withObjectKeys(
-        withPortableTextMarkModel(
-          withPortableTextBlockStyle(
-            withPortableTextLists(
-              withPlaceholderBlock(
-                withUtils(
-                  withMaxBlocks(
-                    withUndoRedo(
-                      withPatches(
-                        withPortableTextSelections(
-                          withEditableAPI(withInsertBreak(e))
+    editor: withEventListeners(
+      withSchemaTypes(
+        withObjectKeys(
+          withPortableTextMarkModel(
+            withPortableTextBlockStyle(
+              withPortableTextLists(
+                withPlaceholderBlock(
+                  withUtils(
+                    withMaxBlocks(
+                      withUndoRedo(
+                        withPatches(
+                          withPortableTextSelections(
+                            withEditableAPI(withInsertBreak(e))
+                          )
                         )
                       )
                     )
@@ -4839,11 +4886,20 @@ const EditorActorContext = createContext({}), behaviorActionImplementations = {
       Transforms.setNodes(event.editor, { style: event.style }, { at });
     }
   },
+  "delete backward": ({ event }) => {
+    Editor.deleteBackward(event.editor, { unit: event.unit });
+  },
   "delete text": ({ event }) => {
     Transforms.delete(event.editor, {
       at: toSlateRange(event.selection, event.editor)
     });
   },
+  "insert break": ({ event }) => {
+    Editor.insertBreak(event.editor);
+  },
+  "insert soft break": ({ event }) => {
+    Editor.insertSoftBreak(event.editor);
+  },
   "insert text": ({ event }) => {
     Editor.insertText(event.editor, event.text);
   },
@@ -4895,12 +4951,14 @@ const EditorActorContext = createContext({}), behaviorActionImplementations = {
       pendingEvents: []
     }),
     "handle behavior event": enqueueActions(({ context, event, enqueue }) => {
-      assertEvent(event, ["key down", "before insert text"]);
+      assertEvent(event, ["behavior event"]);
       const eventBehaviors = context.behaviors.filter(
-        (behavior) => behavior.on === event.type
+        (behavior) => behavior.on === event.behaviorEvent.type
       );
-      if (eventBehaviors.length === 0)
+      if (eventBehaviors.length === 0) {
+        event.behaviorEvent.default();
         return;
+      }
       const value = fromSlateValue(
         event.editor.children,
         context.schema.block.name,
@@ -4913,7 +4971,7 @@ const EditorActorContext = createContext({}), behaviorActionImplementations = {
       if (!selection) {
         console.warn(
           `Unable to handle event ${event.type} due to missing selection`
-        );
+        ), event.behaviorEvent.default();
         return;
       }
       const behaviorContext = {
@@ -4921,22 +4979,27 @@ const EditorActorContext = createContext({}), behaviorActionImplementations = {
         value,
         selection
       };
+      let behaviorOverwritten = !1;
       for (const eventBehavior of eventBehaviors) {
         const shouldRun = eventBehavior.guard?.({
           context: behaviorContext,
-          event
+          event: event.behaviorEvent
         }) ?? !0;
         if (!shouldRun)
           continue;
         const actions = eventBehavior.actions.map(
-          (action) => action({ context: behaviorContext, event }, shouldRun)
+          (action) => action(
+            { context: behaviorContext, event: event.behaviorEvent },
+            shouldRun
+          )
         );
         for (const action of actions)
-          typeof action == "object" && enqueue.raise({
+          typeof action == "object" && (behaviorOverwritten = !0, enqueue.raise({
             ...action,
             editor: event.editor
-          });
+          }));
       }
+      behaviorOverwritten || event.behaviorEvent.default();
     })
   },
   actors: {
@@ -4968,18 +5031,22 @@ const EditorActorContext = createContext({}), behaviorActionImplementations = {
     loading: { actions: emit({ type: "loading" }) },
     "done loading": { actions: emit({ type: "done loading" }) },
     "update schema": { actions: "assign schema" },
-    "key down": {
-      actions: ["handle behavior event"]
-    },
-    "before insert text": {
-      actions: ["handle behavior event"]
-    },
+    "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"]]
     },
@@ -5616,11 +5683,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     [editorActor, onBlur]
   ), handleOnBeforeInput = useCallback(
     (event) => {
-      onBeforeInput && onBeforeInput(event), !event.defaultPrevented && event.inputType === "insertText" && editorActor.send({
-        type: "before insert text",
-        nativeEvent: event,
-        editor: slateEditor
-      });
+      onBeforeInput && onBeforeInput(event);
     },
     [onBeforeInput]
   ), validateSelection = useCallback(() => {
@@ -5659,11 +5722,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
   }, [validateSelection, editableElement]);
   const handleKeyDown = useCallback(
     (event) => {
-      props.onKeyDown && props.onKeyDown(event), event.isDefaultPrevented() || (editorActor.send({
-        type: "key down",
-        nativeEvent: event.nativeEvent,
-        editor: slateEditor
-      }), slateEditor.pteWithHotKeys(event));
+      props.onKeyDown && props.onKeyDown(event), event.isDefaultPrevented() || slateEditor.pteWithHotKeys(event);
     },
     [props, slateEditor]
   ), scrollSelectionIntoViewToSlate = useMemo(() => {