@portabletext/editor 1.54.3 → 1.54.4

package/lib/index.cjs

@@ -4656,13 +4656,10 @@ function createWithPlaceholderBlock(editorActor) {
         return;
       }
       if (op.type === "remove_node") {
-        const node = op.node;
-        if (op.path[0] === 0 && slate.Editor.isVoid(editor, node)) {
-          const nextPath = slate.Path.next(op.path);
-          editor.children[nextPath[0]] || (debug$b("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
-            decorators: []
-          })));
-        }
+        const blockIndex = op.path.at(0), isLonelyBlock = op.path.length === 1 && blockIndex === 0 && editor.children.length === 1, isBlockObject = op.node._type !== editorActor.getSnapshot().context.schema.block.name;
+        isLonelyBlock && isBlockObject && (debug$b("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
+          decorators: []
+        })));
       }
       apply2(op);
     }, editor;
@@ -5189,7 +5186,7 @@ function createSlateEditor(config) {
     relayActor: config.relayActor,
     subscriptions: config.subscriptions
   });
-  KEY_TO_VALUE_ELEMENT.set(instance, {}), KEY_TO_SLATE_ELEMENT.set(instance, {}), instance.decoratorState = {}, instance.markState = void 0, instance.value = [createPlaceholderBlock(config.editorActor.getSnapshot().context)];
+  KEY_TO_VALUE_ELEMENT.set(instance, {}), KEY_TO_SLATE_ELEMENT.set(instance, {}), instance.decoratedRanges = [], instance.decoratorState = {}, instance.markState = void 0, instance.value = [createPlaceholderBlock(config.editorActor.getSnapshot().context)];
   const initialValue = toSlateValue(instance.value, {
     schemaTypes: config.editorActor.getSnapshot().context.schema
   });
@@ -10541,111 +10538,107 @@ const slateOperationCallback = ({
         event
       }) => event.type !== "range decorations updated" ? context.pendingRangeDecorations : event.rangeDecorations
     }),
-    "set up initial range decorations": xstate.assign({
-      decoratedRanges: ({
-        context
-      }) => {
-        const rangeDecorationState = [];
-        for (const rangeDecoration of context.pendingRangeDecorations) {
-          const slateRange = toSlateRange(rangeDecoration.selection, context.slateEditor);
-          if (!slate.Range.isRange(slateRange)) {
-            rangeDecoration.onMoved?.({
-              newSelection: null,
-              rangeDecoration,
-              origin: "local"
-            });
-            continue;
-          }
-          rangeDecorationState.push({
+    "set up initial range decorations": ({
+      context
+    }) => {
+      const rangeDecorationState = [];
+      for (const rangeDecoration of context.pendingRangeDecorations) {
+        const slateRange = toSlateRange(rangeDecoration.selection, context.slateEditor);
+        if (!slate.Range.isRange(slateRange)) {
+          rangeDecoration.onMoved?.({
+            newSelection: null,
             rangeDecoration,
-            ...slateRange
+            origin: "local"
           });
+          continue;
         }
-        return rangeDecorationState;
+        rangeDecorationState.push({
+          rangeDecoration,
+          ...slateRange
+        });
       }
-    }),
-    "update range decorations": xstate.assign({
-      decoratedRanges: ({
-        context,
-        event
-      }) => {
-        if (event.type !== "range decorations updated")
-          return context.decoratedRanges;
-        const rangeDecorationState = [];
-        for (const rangeDecoration of event.rangeDecorations) {
-          const slateRange = toSlateRange(rangeDecoration.selection, context.slateEditor);
-          if (!slate.Range.isRange(slateRange)) {
-            rangeDecoration.onMoved?.({
-              newSelection: null,
-              rangeDecoration,
-              origin: "local"
-            });
-            continue;
-          }
-          rangeDecorationState.push({
+      context.slateEditor.decoratedRanges = rangeDecorationState;
+    },
+    "update range decorations": ({
+      context,
+      event
+    }) => {
+      if (event.type !== "range decorations updated")
+        return;
+      const rangeDecorationState = [];
+      for (const rangeDecoration of event.rangeDecorations) {
+        const slateRange = toSlateRange(rangeDecoration.selection, context.slateEditor);
+        if (!slate.Range.isRange(slateRange)) {
+          rangeDecoration.onMoved?.({
+            newSelection: null,
             rangeDecoration,
-            ...slateRange
+            origin: "local"
           });
+          continue;
         }
-        return rangeDecorationState;
+        rangeDecorationState.push({
+          rangeDecoration,
+          ...slateRange
+        });
       }
-    }),
-    "move range decorations": xstate.assign({
-      decoratedRanges: ({
-        context,
-        event
-      }) => {
-        if (event.type !== "slate operation")
-          return context.decoratedRanges;
-        const rangeDecorationState = [];
-        for (const decoratedRange of context.decoratedRanges) {
-          const slateRange = toSlateRange(decoratedRange.rangeDecoration.selection, context.slateEditor);
-          if (!slate.Range.isRange(slateRange)) {
-            decoratedRange.rangeDecoration.onMoved?.({
-              newSelection: null,
-              rangeDecoration: decoratedRange.rangeDecoration,
-              origin: "local"
-            });
-            continue;
-          }
-          let newRange;
-          if (newRange = moveRangeByOperation(slateRange, event.operation), newRange && newRange !== slateRange || newRange === null && slateRange) {
-            const newRangeSelection = newRange ? slateRangeToSelection({
+      context.slateEditor.decoratedRanges = rangeDecorationState;
+    },
+    "move range decorations": ({
+      context,
+      event
+    }) => {
+      if (event.type !== "slate operation")
+        return;
+      const rangeDecorationState = [];
+      for (const decoratedRange of context.slateEditor.decoratedRanges) {
+        const slateRange = toSlateRange(decoratedRange.rangeDecoration.selection, context.slateEditor);
+        if (!slate.Range.isRange(slateRange)) {
+          decoratedRange.rangeDecoration.onMoved?.({
+            newSelection: null,
+            rangeDecoration: decoratedRange.rangeDecoration,
+            origin: "local"
+          });
+          continue;
+        }
+        let newRange;
+        if (newRange = moveRangeByOperation(slateRange, event.operation), newRange && newRange !== slateRange || newRange === null && slateRange) {
+          const newRangeSelection = newRange ? slateRangeToSelection({
+            schema: context.schema,
+            editor: context.slateEditor,
+            range: newRange
+          }) : null;
+          decoratedRange.rangeDecoration.onMoved?.({
+            newSelection: newRangeSelection,
+            rangeDecoration: decoratedRange.rangeDecoration,
+            origin: "local"
+          });
+        }
+        newRange !== null && rangeDecorationState.push({
+          ...newRange || slateRange,
+          rangeDecoration: {
+            ...decoratedRange.rangeDecoration,
+            selection: slateRangeToSelection({
               schema: context.schema,
               editor: context.slateEditor,
               range: newRange
-            }) : null;
-            decoratedRange.rangeDecoration.onMoved?.({
-              newSelection: newRangeSelection,
-              rangeDecoration: decoratedRange.rangeDecoration,
-              origin: "local"
-            });
+            })
           }
-          newRange !== null && rangeDecorationState.push({
-            ...newRange || slateRange,
-            rangeDecoration: {
-              ...decoratedRange.rangeDecoration,
-              selection: slateRangeToSelection({
-                schema: context.schema,
-                editor: context.slateEditor,
-                range: newRange
-              })
-            }
-          });
-        }
-        return rangeDecorationState;
+        });
       }
-    }),
+      context.slateEditor.decoratedRanges = rangeDecorationState;
+    },
     "assign readOnly": xstate.assign({
       readOnly: ({
         context,
         event
       }) => event.type !== "update read only" ? context.readOnly : event.readOnly
     }),
-    "increment update count": xstate.assign({
-      updateCount: ({
+    "update decorate": xstate.assign({
+      decorate: ({
         context
-      }) => context.updateCount + 1
+      }) => ({
+        fn: createDecorate(context.schema, context.slateEditor)
+      })
     })
   },
   actors: {
@@ -10657,14 +10650,14 @@ const slateOperationCallback = ({
     }) => context.pendingRangeDecorations.length > 0,
     "has range decorations": ({
       context
-    }) => context.decoratedRanges.length > 0,
+    }) => context.slateEditor.decoratedRanges.length > 0,
     "has different decorations": ({
       context,
       event
     }) => {
       if (event.type !== "range decorations updated")
         return !1;
-      const existingRangeDecorations = context.decoratedRanges.map((decoratedRange) => ({
+      const existingRangeDecorations = context.slateEditor.decoratedRanges.map((decoratedRange) => ({
         anchor: decoratedRange.rangeDecoration.selection?.anchor,
         focus: decoratedRange.rangeDecoration.selection?.focus
       })), newRangeDecorations = event.rangeDecorations.map((rangeDecoration) => ({
@@ -10691,7 +10684,9 @@ const slateOperationCallback = ({
     skipSetup: input.skipSetup,
     schema: input.schema,
     slateEditor: input.slateEditor,
-    updateCount: 0
+    decorate: {
+      fn: createDecorate(input.schema, input.slateEditor)
+    }
   }),
   invoke: {
     src: "slate operation listener",
@@ -10712,7 +10707,7 @@ const slateOperationCallback = ({
       always: [{
         guard: xstate.and(["should skip setup", "has pending range decorations"]),
         target: "ready",
-        actions: ["set up initial range decorations", "increment update count"]
+        actions: ["set up initial range decorations", "update decorate"]
       }, {
         guard: "should skip setup",
         target: "ready"
@@ -10724,7 +10719,7 @@ const slateOperationCallback = ({
         ready: [{
           target: "ready",
           guard: "has pending range decorations",
-          actions: ["set up initial range decorations", "increment update count"]
+          actions: ["set up initial range decorations", "update decorate"]
         }, {
           target: "ready"
         }]
@@ -10736,7 +10731,7 @@ const slateOperationCallback = ({
         "range decorations updated": {
           target: ".idle",
           guard: "has different decorations",
-          actions: ["update range decorations", "increment update count"]
+          actions: ["update range decorations", "update decorate"]
         }
       },
       states: {
@@ -10758,9 +10753,9 @@ const slateOperationCallback = ({
     }
   }
 });
-function createDecorate(rangeDecorationActor) {
+function createDecorate(schema2, slateEditor) {
   return function([node, path]) {
-    if (isEqualToEmptyEditor(rangeDecorationActor.getSnapshot().context.slateEditor.children, rangeDecorationActor.getSnapshot().context.schema))
+    if (isEqualToEmptyEditor(slateEditor.children, schema2))
       return [{
         anchor: {
           path: [0, 0],
@@ -10777,7 +10772,7 @@ function createDecorate(rangeDecorationActor) {
     if (!slate.Element.isElement(node) || node.children.length === 0)
       return [];
     const blockIndex = path.at(0);
-    return blockIndex === void 0 ? [] : rangeDecorationActor.getSnapshot().context.decoratedRanges.filter((decoratedRange) => slate.Range.isCollapsed(decoratedRange) ? node.children.some((_, childIndex) => slate.Path.equals(decoratedRange.anchor.path, [blockIndex, childIndex]) && slate.Path.equals(decoratedRange.focus.path, [blockIndex, childIndex])) : slate.Range.intersection(decoratedRange, {
+    return blockIndex === void 0 ? [] : slateEditor.decoratedRanges.filter((decoratedRange) => slate.Range.isCollapsed(decoratedRange) ? node.children.some((_, childIndex) => slate.Path.equals(decoratedRange.anchor.path, [blockIndex, childIndex]) && slate.Path.equals(decoratedRange.focus.path, [blockIndex, childIndex])) : slate.Range.intersection(decoratedRange, {
       anchor: {
         path,
         offset: 0
@@ -10832,9 +10827,7 @@ const debug = debugWithName("component:Editable"), PortableTextEditable = React.
         setup: "setting up"
       })
     }
-  });
-  react.useSelector(rangeDecorationsActor, (s_0) => s_0.context.updateCount);
-  const decorate = React.useMemo(() => createDecorate(rangeDecorationsActor), [rangeDecorationsActor]);
+  }), decorate = react.useSelector(rangeDecorationsActor, (s_0) => s_0.context.decorate?.fn);
   React.useEffect(() => {
     rangeDecorationsActor.send({
       type: "update read only",