@portabletext/editor 1.1.7 → 1.1.9

package/lib/index.js

@@ -1594,11 +1594,11 @@ function createWithInsertBreak(editorActor, types2) {
         (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), isEndAtStartOfBlock = isEqual__default.default(end, {
+        const [start, end] = slate.Range.edges(editor.selection), atTheStartOfBlock = isEqual__default.default(end, {
           path: [...focusBlockPath, 0],
           offset: 0
         });
-        if (isEndAtStartOfBlock && slate.Range.isCollapsed(editor.selection)) {
+        if (atTheStartOfBlock && slate.Range.isCollapsed(editor.selection)) {
           slate.Editor.insertNode(
             editor,
             editor.pteCreateTextBlock({
@@ -1609,32 +1609,28 @@ function createWithInsertBreak(editorActor, types2) {
           slate.Transforms.select(editor, {
             anchor: { path: [nextBlockPath, 0], offset: 0 },
             focus: { path: [nextBlockPath, 0], offset: 0 }
-          }), editor.onChange();
+          });
           return;
         }
-        const lastFocusBlockChild = focusBlock.children[focusBlock.children.length - 1], isStartAtEndOfBlock = isEqual__default.default(start, {
+        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 (isStartAtEndOfBlock && slate.Range.isCollapsed(editor.selection) && focusDecorators.length > 0 && focusAnnotations.length > 0) {
-          slate.Editor.withoutNormalizing(editor, () => {
-            if (!editor.selection)
-              return;
-            slate.Editor.insertNode(
-              editor,
-              editor.pteCreateTextBlock({
-                decorators: []
-              })
-            );
-            const [nextBlockPath] = slate.Path.next(focusBlockPath);
-            slate.Transforms.setSelection(editor, {
-              anchor: { path: [nextBlockPath, 0], offset: 0 },
-              focus: { path: [nextBlockPath, 0], offset: 0 }
-            });
-          }), editor.onChange();
+        if (atTheEndOfBlock && slate.Range.isCollapsed(editor.selection)) {
+          slate.Editor.insertNode(
+            editor,
+            editor.pteCreateTextBlock({
+              decorators: []
+            })
+          );
+          const [nextBlockPath] = slate.Path.next(focusBlockPath);
+          slate.Transforms.setSelection(editor, {
+            anchor: { path: [nextBlockPath, 0], offset: 0 },
+            focus: { path: [nextBlockPath, 0], offset: 0 }
+          });
           return;
         }
-        if (!isEndAtStartOfBlock && !isStartAtEndOfBlock) {
+        if (!atTheStartOfBlock && !atTheEndOfBlock) {
           slate.Editor.withoutNormalizing(editor, () => {
             if (!editor.selection)
               return;
@@ -3494,6 +3490,17 @@ function createWithPortableTextMarkModel(editorActor, types2) {
               }
             }
           }
+          if (atTheBeginningOfSpan && !spanIsEmpty && previousSpan) {
+            slate.Transforms.insertNodes(editor, {
+              _type: "span",
+              _key: editorActor.getSnapshot().context.keyGenerator(),
+              text: op.text,
+              marks: (previousSpan.marks ?? []).filter(
+                (mark) => decorators.includes(mark)
+              )
+            });
+            return;
+          }
         }
       }
       if (op.type === "remove_text") {
@@ -3797,7 +3804,7 @@ const debug$8 = debugWithName("plugin:withHotKeys"), DEFAULT_HOTKEYS = {
   },
   custom: {}
 };
-function createWithHotkeys(types$1, portableTextEditor, hotkeysFromOptions) {
+function createWithHotkeys(portableTextEditor, hotkeysFromOptions) {
   const reservedHotkeys = ["enter", "tab", "shift", "delete", "end"], activeHotkeys = hotkeysFromOptions || DEFAULT_HOTKEYS;
   return function(editor) {
     return editor.pteWithHotKeys = (event) => {
@@ -3878,16 +3885,6 @@ function createWithHotkeys(types$1, portableTextEditor, hotkeysFromOptions) {
           editor.pteEndList() && event.preventDefault();
           return;
         }
-        if (editor.isTextBlock(focusBlock) && focusBlock.style && focusBlock.style !== types$1.styles[0].value) {
-          const [, end] = slate.Range.edges(editor.selection);
-          if (slate.Editor.isEnd(editor, end, end.path)) {
-            slate.Editor.insertNode(
-              editor,
-              editor.pteCreateTextBlock({ decorators: [] })
-            ), event.preventDefault(), editor.onChange();
-            return;
-          }
-        }
       }
     }, editor;
   };
@@ -4371,7 +4368,7 @@ function _insertFragment(editor, fragment, schemaTypes) {
   }), editor.onChange();
 }
 const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, options) => {
-  const e = editor, { portableTextEditor, patches$, readOnly, maxBlocks } = options, { editorActor, schemaTypes } = portableTextEditor;
+  const e = editor, { editorActor, portableTextEditor, patches$, readOnly, maxBlocks } = options, { schemaTypes } = portableTextEditor;
   e.subscriptions = [], e.destroy ? e.destroy() : originalFnMap.set(e, {
     apply: e.apply,
     onChange: e.onChange,
@@ -4469,9 +4466,10 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
   };
 }, debug$6 = debugWithName("component:PortableTextEditor:SlateContainer");
 function SlateContainer(props) {
-  const { patches$, portableTextEditor, readOnly, maxBlocks } = props, [[slateEditor, subscribe]] = react.useState(() => {
+  const { editorActor, patches$, portableTextEditor, readOnly, maxBlocks } = props, [[slateEditor, subscribe]] = react.useState(() => {
     debug$6("Creating new Slate editor instance");
     const { editor, subscribe: _sub } = withPlugins(slateReact.withReact(slate.createEditor()), {
+      editorActor,
       maxBlocks,
       patches$,
       portableTextEditor,
@@ -4486,6 +4484,7 @@ function SlateContainer(props) {
     };
   }, [subscribe]), react.useEffect(() => {
     debug$6("Re-initializing plugin chain"), withPlugins(slateEditor, {
+      editorActor,
       maxBlocks,
       patches$,
       portableTextEditor,
@@ -4506,7 +4505,7 @@ const PortableTextEditorReadOnlyContext = react.createContext(!1), usePortableTe
   return readOnly;
 }, debug$5 = debugWithName("hook:useSyncValue"), CURRENT_VALUE = /* @__PURE__ */ new WeakMap();
 function useSyncValue(props) {
-  const { editorActor, portableTextEditor, readOnly } = props, { schemaTypes } = portableTextEditor, previousValue = react.useRef(), slateEditor = slateReact.useSlate(), updateValueFunctionRef = react.useRef(), updateFromCurrentValue = react.useCallback(() => {
+  const { editorActor, portableTextEditor, readOnly } = props, schemaTypes = editorActor.getSnapshot().context.schema, previousValue = react.useRef(), slateEditor = slateReact.useSlate(), updateValueFunctionRef = react.useRef(), updateFromCurrentValue = react.useCallback(() => {
     const currentValue = CURRENT_VALUE.get(portableTextEditor);
     if (previousValue.current === currentValue) {
       debug$5("Value is the same object as previous, not need to sync");
@@ -4813,30 +4812,40 @@ ${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
-}) {
-  slate.Editor.insertText(event.editor, event.text);
-}
-function inserTextBlock({
-  context,
-  event
-}) {
-  slate.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 = xstate.fromCallback(({ sendBack }) => {
+const EditorActorContext = react.createContext({}), behaviorActionImplementations = {
+  "apply block style": ({ event }) => {
+    for (const path of event.paths) {
+      const at = toSlateRange(
+        { anchor: { path, offset: 0 }, focus: { path, offset: 0 } },
+        event.editor
+      );
+      slate.Transforms.setNodes(event.editor, { style: event.style }, { at });
+    }
+  },
+  "delete text": ({ event }) => {
+    slate.Transforms.delete(event.editor, {
+      at: toSlateRange(event.selection, event.editor)
+    });
+  },
+  "insert text": ({ event }) => {
+    slate.Editor.insertText(event.editor, event.text);
+  },
+  "insert text block": ({ context, event }) => {
+    slate.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: ""
+        }
+      ]
+    });
+  }
+}, networkLogic = xstate.fromCallback(({ sendBack }) => {
   const onlineHandler = () => {
     sendBack({ type: "online" });
   }, offlineHandler = () => {
@@ -4853,12 +4862,6 @@ const networkLogic = xstate.fromCallback(({ sendBack }) => {
     input: {}
   },
   actions: {
-    "apply:insert text": ({ context, event }) => {
-      xstate.assertEvent(event, "insert text"), inserText({ context, event });
-    },
-    "apply:insert text block": ({ context, event }) => {
-      xstate.assertEvent(event, "insert text block"), inserTextBlock({ context, event });
-    },
     "assign schema": xstate.assign({
       schema: ({ event }) => (xstate.assertEvent(event, "update schema"), event.schema)
     }),
@@ -4875,7 +4878,7 @@ const networkLogic = xstate.fromCallback(({ sendBack }) => {
       pendingEvents: []
     }),
     "handle behavior event": xstate.enqueueActions(({ context, event, enqueue }) => {
-      xstate.assertEvent(event, ["key down"]);
+      xstate.assertEvent(event, ["key down", "before insert text"]);
       const eventBehaviors = context.behaviors.filter(
         (behavior) => behavior.on === event.type
       );
@@ -4951,11 +4954,20 @@ const networkLogic = xstate.fromCallback(({ sendBack }) => {
     "key down": {
       actions: ["handle behavior event"]
     },
+    "before insert text": {
+      actions: ["handle behavior event"]
+    },
+    "apply block style": {
+      actions: [behaviorActionImplementations["apply block style"]]
+    },
+    "delete text": {
+      actions: [behaviorActionImplementations["delete text"]]
+    },
     "insert text": {
-      actions: ["apply:insert text"]
+      actions: [behaviorActionImplementations["insert text"]]
     },
     "insert text block": {
-      actions: ["apply:insert text block"]
+      actions: [behaviorActionImplementations["insert text block"]]
     }
   },
   initial: "pristine",
@@ -5029,11 +5041,6 @@ function PortableTextEditorSelectionProvider(props) {
 }
 const defaultKeyGenerator = () => content.randomKey(12), debug$2 = debugWithName("component:PortableTextEditor");
 class PortableTextEditor extends react.Component {
-  /**
-   * @internal
-   * Don't use this API directly. It's subject to change.
-   */
-  editorActor;
   /**
    * An observable of all the editor changes.
    */
@@ -5046,6 +5053,7 @@ class PortableTextEditor extends react.Component {
    * The editor API (currently implemented with Slate).
    */
   editable;
+  editorActor;
   constructor(props) {
     if (super(props), !props.schemaType)
       throw new Error('PortableTextEditor: missing "schemaType" property');
@@ -5078,29 +5086,36 @@ class PortableTextEditor extends react.Component {
   };
   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;
-    return /* @__PURE__ */ jsxRuntime.jsx(
+    return /* @__PURE__ */ jsxRuntime.jsx(EditorActorContext.Provider, { value: this.editorActor, children: /* @__PURE__ */ jsxRuntime.jsx(
       SlateContainer,
       {
+        editorActor: this.editorActor,
         maxBlocks,
         patches$: _patches$,
         portableTextEditor: this,
         readOnly,
-        children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorContext.Provider, { value: this, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorReadOnlyContext.Provider, { value: readOnly, children: /* @__PURE__ */ jsxRuntime.jsxs(PortableTextEditorSelectionProvider, { editorActor: this.editorActor, children: [
-          /* @__PURE__ */ jsxRuntime.jsx(
-            Synchronizer,
-            {
-              editorActor: this.editorActor,
-              getValue: this.getValue,
-              onChange: (change) => {
-                this.props.onChange(change), this.change$.next(change);
-              },
-              value
-            }
-          ),
-          children
-        ] }) }) })
+        children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorContext.Provider, { value: this, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorReadOnlyContext.Provider, { value: readOnly, children: /* @__PURE__ */ jsxRuntime.jsxs(
+          PortableTextEditorSelectionProvider,
+          {
+            editorActor: this.editorActor,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                Synchronizer,
+                {
+                  editorActor: this.editorActor,
+                  getValue: this.getValue,
+                  onChange: (change) => {
+                    this.props.onChange(change), this.change$.next(change);
+                  },
+                  value
+                }
+              ),
+              children
+            ]
+          }
+        ) }) })
       }
-    );
+    ) });
   }
   // Static API methods
   static activeAnnotations = (editor) => editor && editor.editable ? editor.editable.activeAnnotations() : [];
@@ -5154,6 +5169,7 @@ class PortableTextEditor extends react.Component {
 }
 const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (props) => {
   const {
+    editorActor,
     attributes,
     children,
     leaf,
@@ -5208,17 +5224,14 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
   react.useEffect(() => {
     if (!shouldTrackSelectionAndFocus)
       return;
-    const onBlur = portableTextEditor.editorActor.on("blur", () => {
+    const onBlur = editorActor.on("blur", () => {
       setFocused(!1), setSelected(!1);
-    }), onFocus = portableTextEditor.editorActor.on("focus", () => {
+    }), onFocus = editorActor.on("focus", () => {
       const sel = PortableTextEditor.getSelection(portableTextEditor);
       sel && isEqual__default.default(sel.focus.path, path) && PortableTextEditor.isCollapsedSelection(portableTextEditor) && setFocused(!0), setSelectedFromRange();
-    }), onSelection = portableTextEditor.editorActor.on(
-      "selection",
-      (event) => {
-        event.selection && isEqual__default.default(event.selection.focus.path, path) && PortableTextEditor.isCollapsedSelection(portableTextEditor) ? setFocused(!0) : setFocused(!1), setSelectedFromRange();
-      }
-    );
+    }), onSelection = editorActor.on("selection", (event) => {
+      event.selection && isEqual__default.default(event.selection.focus.path, path) && PortableTextEditor.isCollapsedSelection(portableTextEditor) ? setFocused(!0) : setFocused(!1), setSelectedFromRange();
+    });
     return () => {
       onBlur.unsubscribe(), onFocus.unsubscribe(), onSelection.unsubscribe();
     };
@@ -5371,12 +5384,12 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     forwardedRef,
     () => ref.current
   );
-  const rangeDecorationsRef = react.useRef(rangeDecorations), { editorActor, schemaTypes } = portableTextEditor, slateEditor = slateReact.useSlate(), blockTypeName = schemaTypes.block.name, withInsertData = react.useMemo(
+  const rangeDecorationsRef = react.useRef(rangeDecorations), editorActor = react.useContext(EditorActorContext), { schemaTypes } = portableTextEditor, slateEditor = slateReact.useSlate(), blockTypeName = schemaTypes.block.name, withInsertData = react.useMemo(
     () => createWithInsertData(editorActor, schemaTypes),
     [editorActor, schemaTypes]
   ), withHotKeys = react.useMemo(
-    () => createWithHotkeys(schemaTypes, portableTextEditor, hotkeys),
-    [hotkeys, portableTextEditor, schemaTypes]
+    () => createWithHotkeys(portableTextEditor, hotkeys),
+    [hotkeys, portableTextEditor]
   );
   react.useMemo(() => readOnly ? (debug("Editable is in read only mode"), withInsertData(slateEditor)) : (debug("Editable is in edit mode"), withInsertData(withHotKeys(slateEditor))), [readOnly, slateEditor, withHotKeys, withInsertData]);
   const renderElement = react.useCallback(
@@ -5409,6 +5422,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
           Leaf,
           {
             ...lProps,
+            editorActor,
             schemaTypes,
             renderAnnotation,
             renderChild,
@@ -5585,7 +5599,11 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     [editorActor, onBlur]
   ), handleOnBeforeInput = react.useCallback(
     (event) => {
-      onBeforeInput && onBeforeInput(event);
+      onBeforeInput && onBeforeInput(event), !event.defaultPrevented && event.inputType === "insertText" && editorActor.send({
+        type: "before insert text",
+        nativeEvent: event,
+        editor: slateEditor
+      });
     },
     [onBeforeInput]
   ), validateSelection = react.useCallback(() => {