@portabletext/editor 1.1.7 → 1.1.8

package/src/editor/plugins/createWithInsertBreak.ts

@@ -47,12 +47,12 @@ export function createWithInsertBreak(
 
       if (editor.isTextBlock(focusBlock)) {
         const [start, end] = Range.edges(editor.selection)
-        const isEndAtStartOfBlock = isEqual(end, {
+        const atTheStartOfBlock = isEqual(end, {
           path: [...focusBlockPath, 0],
           offset: 0,
         })
 
-        if (isEndAtStartOfBlock && Range.isCollapsed(editor.selection)) {
+        if (atTheStartOfBlock && Range.isCollapsed(editor.selection)) {
           Editor.insertNode(
             editor,
             editor.pteCreateTextBlock({
@@ -67,49 +67,37 @@ export function createWithInsertBreak(
             focus: {path: [nextBlockPath, 0], offset: 0},
           })
 
-          editor.onChange()
           return
         }
 
         const lastFocusBlockChild =
           focusBlock.children[focusBlock.children.length - 1]
-        const isStartAtEndOfBlock = isEqual(start, {
+        const atTheEndOfBlock = isEqual(start, {
           path: [...focusBlockPath, focusBlock.children.length - 1],
           offset: editor.isTextSpan(lastFocusBlockChild)
             ? lastFocusBlockChild.text.length
             : 0,
         })
 
-        if (
-          isStartAtEndOfBlock &&
-          Range.isCollapsed(editor.selection) &&
-          focusDecorators.length > 0 &&
-          focusAnnotations.length > 0
-        ) {
-          Editor.withoutNormalizing(editor, () => {
-            if (!editor.selection) {
-              return
-            }
-
-            Editor.insertNode(
-              editor,
-              editor.pteCreateTextBlock({
-                decorators: [],
-              }),
-            )
+        if (atTheEndOfBlock && Range.isCollapsed(editor.selection)) {
+          Editor.insertNode(
+            editor,
+            editor.pteCreateTextBlock({
+              decorators: [],
+            }),
+          )
 
-            const [nextBlockPath] = Path.next(focusBlockPath)
+          const [nextBlockPath] = Path.next(focusBlockPath)
 
-            Transforms.setSelection(editor, {
-              anchor: {path: [nextBlockPath, 0], offset: 0},
-              focus: {path: [nextBlockPath, 0], offset: 0},
-            })
+          Transforms.setSelection(editor, {
+            anchor: {path: [nextBlockPath, 0], offset: 0},
+            focus: {path: [nextBlockPath, 0], offset: 0},
           })
-          editor.onChange()
+
           return
         }
 
-        const isInTheMiddleOfNode = !isEndAtStartOfBlock && !isStartAtEndOfBlock
+        const isInTheMiddleOfNode = !atTheStartOfBlock && !atTheEndOfBlock
 
         if (isInTheMiddleOfNode) {
           Editor.withoutNormalizing(editor, () => {

package/src/editor/plugins/index.ts

@@ -47,8 +47,9 @@ export const withPlugins = <T extends Editor>(
   options: createEditorOptions,
 ): {editor: PortableTextSlateEditor; subscribe: () => () => void} => {
   const e = editor as T & PortableTextSlateEditor
-  const {portableTextEditor, patches$, readOnly, maxBlocks} = options
-  const {editorActor, schemaTypes} = portableTextEditor
+  const {editorActor, portableTextEditor, patches$, readOnly, maxBlocks} =
+    options
+  const {schemaTypes} = portableTextEditor
   e.subscriptions = []
   if (e.destroy) {
     e.destroy()

package/src/types/options.ts

@@ -1,4 +1,5 @@
 import type {BaseSyntheticEvent} from 'react'
+import type {EditorActor} from '../editor/editor-machine'
 import type {PortableTextEditor} from '../editor/PortableTextEditor'
 import type {PatchObservable} from './editor'
 
@@ -6,6 +7,7 @@ import type {PatchObservable} from './editor'
  * @internal
  */
 export type createEditorOptions = {
+  editorActor: EditorActor
   patches$?: PatchObservable
   portableTextEditor: PortableTextEditor
   readOnly: boolean

package/src/utils/__tests__/operationToPatches.test.ts

@@ -1,8 +1,15 @@
 import type {PortableTextTextBlock} from '@sanity/types'
 import {createEditor, type Descendant} from 'slate'
 import {beforeEach, describe, expect, it} from 'vitest'
-import {PortableTextEditor, type PortableTextEditorProps} from '../..'
+import {createActor} from 'xstate'
+import {
+  editorMachine,
+  PortableTextEditor,
+  type PortableTextEditorProps,
+} from '../..'
 import {schemaType} from '../../editor/__tests__/PortableTextEditorTester'
+import {coreBehaviors} from '../../editor/behavior/behavior.core'
+import {defaultKeyGenerator} from '../../editor/key-generator'
 import {withPlugins} from '../../editor/plugins'
 import {getPortableTextMemberSchemaTypes} from '../getPortableTextMemberSchemaTypes'
 import {createOperationToPatches} from '../operationToPatches'
@@ -12,6 +19,13 @@ const portableTextFeatures = getPortableTextMemberSchemaTypes(schemaType)
 const operationToPatches = createOperationToPatches(portableTextFeatures)
 
 const {editor} = withPlugins(createEditor(), {
+  editorActor: createActor(editorMachine, {
+    input: {
+      behaviors: coreBehaviors,
+      schema: schemaType,
+      keyGenerator: defaultKeyGenerator,
+    },
+  }),
   portableTextEditor: new PortableTextEditor({
     schemaType,
   } as PortableTextEditorProps),

package/src/utils/__tests__/patchToOperations.test.ts

@@ -2,8 +2,11 @@ import type {Patch} from '@portabletext/patches'
 import {noop} from 'lodash'
 import {createEditor, type Descendant} from 'slate'
 import {beforeEach, describe, expect, it} from 'vitest'
-import {PortableTextEditor} from '../..'
+import {createActor} from 'xstate'
+import {editorMachine, PortableTextEditor} from '../..'
 import {schemaType} from '../../editor/__tests__/PortableTextEditorTester'
+import {coreBehaviors} from '../../editor/behavior/behavior.core'
+import {defaultKeyGenerator} from '../../editor/key-generator'
 import {withPlugins} from '../../editor/plugins'
 import {createApplyPatch} from '../applyPatch'
 import {getPortableTextMemberSchemaTypes} from '../getPortableTextMemberSchemaTypes'
@@ -15,6 +18,13 @@ const patchToOperations = createApplyPatch(schemaTypes)
 const portableTextEditor = new PortableTextEditor({schemaType, onChange: noop})
 
 const {editor} = withPlugins(createEditor(), {
+  editorActor: createActor(editorMachine, {
+    input: {
+      behaviors: coreBehaviors,
+      schema: schemaTypes,
+      keyGenerator: defaultKeyGenerator,
+    },
+  }),
   portableTextEditor,
   readOnly: false,
 })