@portabletext/editor 2.14.0 → 2.14.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "2.14.0",
+  "version": "2.14.1",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",

package/src/behaviors/behavior.abstract.insert.ts

@@ -1,5 +1,6 @@
 import {getFocusTextBlock} from '../selectors/selector.get-focus-text-block'
 import {getLastBlock} from '../selectors/selector.get-last-block'
+import {isSelectionCollapsed} from '../utils'
 import {getBlockEndPoint} from '../utils/util.get-block-end-point'
 import {getBlockStartPoint} from '../utils/util.get-block-start-point'
 import {isEmptyTextBlock} from '../utils/util.is-empty-text-block'
@@ -472,4 +473,22 @@ export const abstractInsertBehaviors = [
       ],
     ],
   }),
+  defineBehavior({
+    on: 'insert.text',
+    guard: ({snapshot}) => {
+      const selection = snapshot.context.selection
+
+      if (!selection || isSelectionCollapsed(selection)) {
+        return false
+      }
+
+      return {selection}
+    },
+    actions: [
+      ({event}, {selection}) => [
+        raise({type: 'delete', at: selection}),
+        raise(event),
+      ],
+    ],
+  }),
 ]

package/src/editor/editor-machine.ts

@@ -34,6 +34,7 @@ import type {
   MutationEvent,
   PatchEvent,
 } from './relay-machine'
+import {isNormalizingNode} from './with-normalizing-node'
 
 export * from 'xstate/guards'
 
@@ -93,16 +94,10 @@ export type InternalEditorEvent =
       type: 'focus'
       editor: PortableTextSlateEditor
     }
-  | {
-      type: 'normalizing'
-    }
   | {
       type: 'update selection'
       selection: EditorSelection
     }
-  | {
-      type: 'done normalizing'
-    }
   | {
       type: 'done syncing value'
     }
@@ -128,6 +123,7 @@ export type InternalEditorEvent =
     }
   | {type: 'dragend'}
   | {type: 'drop'}
+  | {type: 'add slate editor'; editor: PortableTextSlateEditor}
 
 /**
  * @internal
@@ -235,6 +231,13 @@ export const editorMachine = setup({
         return new Set([...context.behaviors])
       },
     }),
+    'add slate editor to context': assign({
+      slateEditor: ({context, event}) => {
+        return event.type === 'add slate editor'
+          ? event.editor
+          : context.slateEditor
+      },
+    }),
     'emit patch event': emit(({event}) => {
       assertEvent(event, 'internal.patch')
       return event
@@ -363,6 +366,13 @@ export const editorMachine = setup({
 
       return context.slateEditor.operations.length > 0
     },
+    'slate is normalizing node': ({context}) => {
+      if (!context.slateEditor) {
+        return false
+      }
+
+      return isNormalizingNode(context.slateEditor)
+    },
   },
 }).createMachine({
   id: 'editor',
@@ -386,6 +396,7 @@ export const editorMachine = setup({
     'update maxBlocks': {
       actions: assign({maxBlocks: ({event}) => event.maxBlocks}),
     },
+    'add slate editor': {actions: 'add slate editor to context'},
     'update selection': {
       actions: [
         assign({selection: ({event}) => event.selection}),
@@ -694,44 +705,26 @@ export const editorMachine = setup({
                         },
                       ],
                       on: {
-                        'normalizing': {
-                          target: 'normalizing',
-                        },
-                        'internal.patch': {
-                          actions: 'defer event',
-                          target: '#editor.setup.set up.writing.dirty',
-                        },
-                        'mutation': {
-                          actions: 'defer event',
-                          target: '#editor.setup.set up.writing.dirty',
-                        },
-                      },
-                    },
-                    normalizing: {
-                      entry: [
-                        () => {
-                          debug(
-                            'entry: setup->set up->writing->pristine->normalizing',
-                          )
-                        },
-                      ],
-                      exit: [
-                        () => {
-                          debug(
-                            'exit: setup->set up->writing->pristine->normalizing',
-                          )
-                        },
-                      ],
-                      on: {
-                        'done normalizing': {
-                          target: 'idle',
-                        },
-                        'internal.patch': {
-                          actions: 'defer event',
-                        },
-                        'mutation': {
-                          actions: 'defer event',
-                        },
+                        'internal.patch': [
+                          {
+                            guard: 'slate is normalizing node',
+                            actions: 'defer event',
+                          },
+                          {
+                            actions: 'defer event',
+                            target: '#editor.setup.set up.writing.dirty',
+                          },
+                        ],
+                        'mutation': [
+                          {
+                            guard: 'slate is normalizing node',
+                            actions: 'defer event',
+                          },
+                          {
+                            actions: 'defer event',
+                            target: '#editor.setup.set up.writing.dirty',
+                          },
+                        ],
                       },
                     },
                   },

package/src/editor/editor-provider.tsx

@@ -70,6 +70,10 @@ export function EditorProvider(props: EditorProviderProps) {
     unsubscribers.push(relayActorSubscription.unsubscribe)
 
     internalEditor.actors.editorActor.start()
+    internalEditor.actors.editorActor.send({
+      type: 'add slate editor',
+      editor: internalEditor.editor._internal.slateEditor.instance,
+    })
     internalEditor.actors.mutationActor.start()
     internalEditor.actors.relayActor.start()
     internalEditor.actors.syncActor.start()

package/src/editor/plugins/createWithObjectKeys.ts

@@ -3,6 +3,7 @@ import {isEqual} from 'lodash'
 import {Editor, Element, Node, Path, Transforms} from 'slate'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
+import {withNormalizeNode} from '../with-normalizing-node'
 import {isChangingRemotely} from '../withChanges'
 import {isRedoing, isUndoing} from '../withUndoRedo'
 
@@ -198,30 +199,33 @@ export function createWithObjectKeys(editorActor: EditorActor) {
       ) {
         // Set key on block itself
         if (!node._key) {
-          editorActor.send({type: 'normalizing'})
-          Transforms.setNodes(
-            editor,
-            {_key: editorActor.getSnapshot().context.keyGenerator()},
-            {at: path},
-          )
-          editorActor.send({type: 'done normalizing'})
+          withNormalizeNode(editor, () => {
+            Transforms.setNodes(
+              editor,
+              {_key: editorActor.getSnapshot().context.keyGenerator()},
+              {at: path},
+            )
+          })
           return
         }
         // Set keys on it's children
         for (const [child, childPath] of Node.children(editor, path)) {
           if (!child._key) {
-            editorActor.send({type: 'normalizing'})
-            Transforms.setNodes(
-              editor,
-              {_key: editorActor.getSnapshot().context.keyGenerator()},
-              {at: childPath},
-            )
-            editorActor.send({type: 'done normalizing'})
+            withNormalizeNode(editor, () => {
+              Transforms.setNodes(
+                editor,
+                {_key: editorActor.getSnapshot().context.keyGenerator()},
+                {at: childPath},
+              )
+            })
             return
           }
         }
       }
-      normalizeNode(entry)
+
+      withNormalizeNode(editor, () => {
+        normalizeNode(entry)
+      })
     }
 
     return editor

package/src/editor/plugins/createWithPortableTextMarkModel.ts

@@ -15,6 +15,7 @@ import {getActiveDecorators} from '../../selectors/selector.get-active-decorator
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
 import {getEditorSnapshot} from '../editor-selector'
+import {withNormalizeNode} from '../with-normalizing-node'
 import {isChangingRemotely} from '../withChanges'
 import {isRedoing, isUndoing} from '../withUndoRedo'
 
@@ -50,12 +51,12 @@ export function createWithPortableTextMarkModel(
               JSON.stringify(child, null, 2),
               JSON.stringify(nextNode, null, 2),
             )
-            editorActor.send({type: 'normalizing'})
-            Transforms.mergeNodes(editor, {
-              at: [childPath[0], childPath[1] + 1],
-              voids: true,
+            withNormalizeNode(editor, () => {
+              Transforms.mergeNodes(editor, {
+                at: [childPath[0], childPath[1] + 1],
+                voids: true,
+              })
             })
-            editorActor.send({type: 'done normalizing'})
             return
           }
         }
@@ -66,9 +67,9 @@ export function createWithPortableTextMarkModel(
        */
       if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
         debug('Adding .markDefs to block node')
-        editorActor.send({type: 'normalizing'})
-        Transforms.setNodes(editor, {markDefs: []}, {at: path})
-        editorActor.send({type: 'done normalizing'})
+        withNormalizeNode(editor, () => {
+          Transforms.setNodes(editor, {markDefs: []}, {at: path})
+        })
         return
       }
 
@@ -77,9 +78,9 @@ export function createWithPortableTextMarkModel(
        */
       if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
         debug('Adding .marks to span node')
-        editorActor.send({type: 'normalizing'})
-        Transforms.setNodes(editor, {marks: []}, {at: path})
-        editorActor.send({type: 'done normalizing'})
+        withNormalizeNode(editor, () => {
+          Transforms.setNodes(editor, {marks: []}, {at: path})
+        })
         return
       }
 
@@ -99,13 +100,17 @@ export function createWithPortableTextMarkModel(
         if (editor.isTextBlock(block)) {
           if (node.text === '' && annotations && annotations.length > 0) {
             debug('Removing annotations from empty span node')
-            editorActor.send({type: 'normalizing'})
-            Transforms.setNodes(
-              editor,
-              {marks: node.marks?.filter((mark) => decorators.includes(mark))},
-              {at: path},
-            )
-            editorActor.send({type: 'done normalizing'})
+            withNormalizeNode(editor, () => {
+              Transforms.setNodes(
+                editor,
+                {
+                  marks: node.marks?.filter((mark) =>
+                    decorators.includes(mark),
+                  ),
+                },
+                {at: path},
+              )
+            })
             return
           }
         }
@@ -131,17 +136,17 @@ export function createWithPortableTextMarkModel(
 
             if (orphanedAnnotations.length > 0) {
               debug('Removing orphaned annotations from span node')
-              editorActor.send({type: 'normalizing'})
-              Transforms.setNodes(
-                editor,
-                {
-                  marks: marks.filter(
-                    (mark) => !orphanedAnnotations.includes(mark),
-                  ),
-                },
-                {at: childPath},
-              )
-              editorActor.send({type: 'done normalizing'})
+              withNormalizeNode(editor, () => {
+                Transforms.setNodes(
+                  editor,
+                  {
+                    marks: marks.filter(
+                      (mark) => !orphanedAnnotations.includes(mark),
+                    ),
+                  },
+                  {at: childPath},
+                )
+              })
               return
             }
           }
@@ -169,17 +174,17 @@ export function createWithPortableTextMarkModel(
 
           if (orphanedAnnotations.length > 0) {
             debug('Removing orphaned annotations from span node')
-            editorActor.send({type: 'normalizing'})
-            Transforms.setNodes(
-              editor,
-              {
-                marks: marks.filter(
-                  (mark) => !orphanedAnnotations.includes(mark),
-                ),
-              },
-              {at: path},
-            )
-            editorActor.send({type: 'done normalizing'})
+            withNormalizeNode(editor, () => {
+              Transforms.setNodes(
+                editor,
+                {
+                  marks: marks.filter(
+                    (mark) => !orphanedAnnotations.includes(mark),
+                  ),
+                },
+                {at: path},
+              )
+            })
             return
           }
         }
@@ -200,9 +205,9 @@ export function createWithPortableTextMarkModel(
 
         if (markDefs.length !== newMarkDefs.length) {
           debug('Removing duplicate markDefs')
-          editorActor.send({type: 'normalizing'})
-          Transforms.setNodes(editor, {markDefs: newMarkDefs}, {at: path})
-          editorActor.send({type: 'done normalizing'})
+          withNormalizeNode(editor, () => {
+            Transforms.setNodes(editor, {markDefs: newMarkDefs}, {at: path})
+          })
           return
         }
       }
@@ -228,20 +233,22 @@ export function createWithPortableTextMarkModel(
         })
         if (node.markDefs && !isEqual(newMarkDefs, node.markDefs)) {
           debug('Removing markDef not in use')
-          editorActor.send({type: 'normalizing'})
-          Transforms.setNodes(
-            editor,
-            {
-              markDefs: newMarkDefs,
-            },
-            {at: path},
-          )
-          editorActor.send({type: 'done normalizing'})
+          withNormalizeNode(editor, () => {
+            Transforms.setNodes(
+              editor,
+              {
+                markDefs: newMarkDefs,
+              },
+              {at: path},
+            )
+          })
           return
         }
       }
 
-      normalizeNode(nodeEntry)
+      withNormalizeNode(editor, () => {
+        normalizeNode(nodeEntry)
+      })
     }
 
     editor.apply = (op) => {

package/src/editor/plugins/createWithSchemaTypes.ts

@@ -9,6 +9,7 @@ import {debugWithName} from '../../internal-utils/debug'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import {isListBlock} from '../../utils/parse-blocks'
 import type {EditorActor} from '../editor-machine'
+import {withNormalizeNode} from '../with-normalizing-node'
 
 const debug = debugWithName('plugin:withSchemaTypes')
 /**
@@ -87,17 +88,17 @@ export function createWithSchemaTypes({
         const span = node as PortableTextSpan
         const key =
           span._key || editorActor.getSnapshot().context.keyGenerator()
-        editorActor.send({type: 'normalizing'})
-        Transforms.setNodes(
-          editor,
-          {
-            ...span,
-            _type: editorActor.getSnapshot().context.schema.span.name,
-            _key: key,
-          },
-          {at: path},
-        )
-        editorActor.send({type: 'done normalizing'})
+        withNormalizeNode(editor, () => {
+          Transforms.setNodes(
+            editor,
+            {
+              ...span,
+              _type: editorActor.getSnapshot().context.schema.span.name,
+              _key: key,
+            },
+            {at: path},
+          )
+        })
         return
       }
 
@@ -105,13 +106,15 @@ export function createWithSchemaTypes({
       if (node._key === undefined && (path.length === 1 || path.length === 2)) {
         debug('Setting missing key on child node without a key')
         const key = editorActor.getSnapshot().context.keyGenerator()
-        editorActor.send({type: 'normalizing'})
-        Transforms.setNodes(editor, {_key: key}, {at: path})
-        editorActor.send({type: 'done normalizing'})
+        withNormalizeNode(editor, () => {
+          Transforms.setNodes(editor, {_key: key}, {at: path})
+        })
         return
       }
 
-      normalizeNode(entry)
+      withNormalizeNode(editor, () => {
+        normalizeNode(entry)
+      })
     }
     return editor
   }

package/src/editor/plugins/createWithUndoRedo.ts

@@ -25,6 +25,7 @@ import {fromSlateValue} from '../../internal-utils/values'
 import type {BehaviorOperationImplementation} from '../../operations/behavior.operations'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
+import {isNormalizingNode} from '../with-normalizing-node'
 import {getCurrentUndoStepId} from '../with-undo-step'
 import {isChangingRemotely} from '../withChanges'
 import {
@@ -151,7 +152,8 @@ export function createWithUndoRedo(
 
       const currentUndoStepId = getCurrentUndoStepId(editor)
 
-      let merge = currentUndoStepId === previousUndoStepId
+      let merge =
+        currentUndoStepId === previousUndoStepId || isNormalizingNode(editor)
 
       if (save) {
         if (!step) {

package/src/editor/with-normalizing-node.ts

@@ -0,0 +1,14 @@
+import {Editor} from 'slate'
+
+const IS_NORMALIZING_NODE: WeakMap<Editor, boolean | undefined> = new WeakMap()
+
+export function withNormalizeNode(editor: Editor, fn: () => void) {
+  const prev = IS_NORMALIZING_NODE.get(editor)
+  IS_NORMALIZING_NODE.set(editor, true)
+  fn()
+  IS_NORMALIZING_NODE.set(editor, prev)
+}
+
+export function isNormalizingNode(editor: Editor) {
+  return IS_NORMALIZING_NODE.get(editor) ?? false
+}