@portabletext/editor 1.49.12 → 1.49.13

package/lib/utils/index.d.ts

@@ -1280,6 +1280,142 @@ declare const editorMachine: StateMachine<
             never,
             never
           >,
+          ActionFunction<
+            {
+              behaviors: Set<BehaviorConfig>
+              converters: Set<Converter>
+              getLegacySchema: () => PortableTextMemberSchemaTypes
+              keyGenerator: () => string
+              pendingEvents: Array<InternalPatchEvent | MutationEvent>
+              pendingIncomingPatchesEvents: Array<PatchesEvent>
+              schema: EditorSchema
+              initialReadOnly: boolean
+              maxBlocks: number | undefined
+              selection: EditorSelection
+              initialValue: Array<PortableTextBlock> | undefined
+              internalDrag?: {
+                ghost?: HTMLElement
+                origin: Pick<EventPosition, 'selection'>
+              }
+              slateEditor?: PortableTextSlateEditor
+            },
+            {
+              type: 'update selection'
+              selection: EditorSelection
+            },
+            | InternalPatchEvent
+            | MutationEvent
+            | PatchesEvent
+            | {
+                type: 'update readOnly'
+                readOnly: boolean
+              }
+            | {
+                type: 'update maxBlocks'
+                maxBlocks: number | undefined
+              }
+            | {
+                type: 'add behavior'
+                behaviorConfig: BehaviorConfig
+              }
+            | {
+                type: 'remove behavior'
+                behaviorConfig: BehaviorConfig
+              }
+            | {
+                type: 'blur'
+                editor: PortableTextSlateEditor
+              }
+            | {
+                type: 'focus'
+                editor: PortableTextSlateEditor
+              }
+            | {
+                type: 'normalizing'
+              }
+            | {
+                type: 'update selection'
+                selection: EditorSelection
+              }
+            | {
+                type: 'done normalizing'
+              }
+            | {
+                type: 'done syncing value'
+              }
+            | {
+                type: 'syncing value'
+              }
+            | {
+                type: 'behavior event'
+                behaviorEvent: BehaviorEvent
+                editor: PortableTextSlateEditor
+                nativeEvent?: {
+                  preventDefault: () => void
+                }
+              }
+            | {
+                type: 'dragstart'
+                origin: Pick<EventPosition, 'selection'>
+                ghost?: HTMLElement
+              }
+            | {
+                type: 'dragend'
+              }
+            | {
+                type: 'drop'
+              },
+            undefined,
+            never,
+            never,
+            never,
+            never,
+            | InternalPatchEvent
+            | MutationEvent
+            | PatchesEvent
+            | {
+                type: 'blurred'
+                event: FocusEvent_2<HTMLDivElement, Element>
+              }
+            | {
+                type: 'done loading'
+              }
+            | {
+                type: 'editable'
+              }
+            | {
+                type: 'error'
+                name: string
+                description: string
+                data: unknown
+              }
+            | {
+                type: 'focused'
+                event: FocusEvent_2<HTMLDivElement, Element>
+              }
+            | {
+                type: 'invalid value'
+                resolution: InvalidValueResolution | null
+                value: Array<PortableTextBlock> | undefined
+              }
+            | {
+                type: 'loading'
+              }
+            | {
+                type: 'read only'
+              }
+            | {
+                type: 'ready'
+              }
+            | {
+                type: 'selection'
+                selection: EditorSelection
+              }
+            | {
+                type: 'value changed'
+                value: Array<PortableTextBlock> | undefined
+              }
+          >,
         ]
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "1.49.12",
+  "version": "1.49.13",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -79,8 +79,8 @@
     "slate-react": "0.114.2",
     "use-effect-event": "^1.0.2",
     "xstate": "^5.19.2",
-    "@portabletext/block-tools": "1.1.26",
-    "@portabletext/patches": "1.1.3"
+    "@portabletext/patches": "1.1.3",
+    "@portabletext/block-tools": "1.1.26"
   },
   "devDependencies": {
     "@portabletext/toolkit": "^2.0.17",

package/src/editor/Editable.tsx

@@ -284,8 +284,8 @@ export const PortableTextEditable = forwardRef<
           // Output selection here in those cases where the editor selection was the same, and there are no set_selection operations made.
           // The selection is usually automatically emitted to change$ by the withPortableTextSelections plugin whenever there is a set_selection operation applied.
           if (!slateEditor.operations.some((o) => o.type === 'set_selection')) {
-            relayActor.send({
-              type: 'selection',
+            editorActor.send({
+              type: 'update selection',
               selection: normalizedSelection,
             })
           }
@@ -293,7 +293,7 @@ export const PortableTextEditable = forwardRef<
         }
       }
     }
-  }, [editorActor, propsSelection, relayActor, slateEditor])
+  }, [editorActor, propsSelection, slateEditor])
 
   // Restore selection from props when the editor has been initialized properly with it's value
   useEffect(() => {
@@ -550,14 +550,14 @@ export const PortableTextEditable = forwardRef<
         const newSelection = PortableTextEditor.getSelection(portableTextEditor)
         // If the selection is the same, emit it explicitly here as there is no actual onChange event triggered.
         if (selection === newSelection) {
-          relayActor.send({
-            type: 'selection',
+          editorActor.send({
+            type: 'update selection',
             selection,
           })
         }
       }
     },
-    [onFocus, slateEditor, portableTextEditor, relayActor],
+    [editorActor, onFocus, slateEditor, portableTextEditor, relayActor],
   )
 
   const handleClick = useCallback(

package/src/editor/__tests__/self-solving.test.tsx

@@ -127,24 +127,24 @@ describe('Feature: Self-solving', () => {
           },
         })
         expect(onChange).toHaveBeenNthCalledWith(4, {
-          type: 'selection',
-          selection: {
-            ...getTextSelection(initialValue, 'foo'),
-            backward: false,
-          },
-        })
-        expect(onChange).toHaveBeenNthCalledWith(5, {
           type: 'patch',
           patch: spanPatch,
         })
-        expect(onChange).toHaveBeenNthCalledWith(6, {
+        expect(onChange).toHaveBeenNthCalledWith(5, {
           type: 'patch',
           patch: blockPatch,
         })
-        expect(onChange).toHaveBeenNthCalledWith(7, {
+        expect(onChange).toHaveBeenNthCalledWith(6, {
           type: 'patch',
           patch: strongPatch,
         })
+        expect(onChange).toHaveBeenNthCalledWith(7, {
+          type: 'selection',
+          selection: {
+            ...getTextSelection(initialValue, 'foo'),
+            backward: false,
+          },
+        })
         expect(onChange).toHaveBeenNthCalledWith(8, {
           type: 'mutation',
           patches: [spanPatch, blockPatch],

package/src/editor/create-editor.ts

@@ -271,21 +271,6 @@ function createActors(config: {
     }
   })
 
-  config.subscriptions.push(() => {
-    const subscription = config.relayActor.on('*', (event) => {
-      if (event.type === 'selection') {
-        config.editorActor.send({
-          type: 'update selection',
-          selection: event.selection,
-        })
-      }
-    })
-
-    return () => {
-      subscription.unsubscribe()
-    }
-  })
-
   config.subscriptions.push(() => {
     const subscription = syncActor.on('*', (event) => {
       switch (event.type) {
@@ -340,6 +325,7 @@ function createActors(config: {
         case 'mutation':
         case 'ready':
         case 'read only':
+        case 'selection':
           config.relayActor.send(event)
           break
         case 'internal.patch':

package/src/editor/editor-machine.ts

@@ -319,7 +319,10 @@ export const editorMachine = setup({
       actions: assign({maxBlocks: ({event}) => event.maxBlocks}),
     },
     'update selection': {
-      actions: [assign({selection: ({event}) => event.selection})],
+      actions: [
+        assign({selection: ({event}) => event.selection}),
+        emit(({event}) => ({...event, type: 'selection'})),
+      ],
     },
   },
   type: 'parallel',

package/src/editor/plugins/createWithPortableTextSelections.ts

@@ -4,7 +4,6 @@ import {slateRangeToSelection} from '../../internal-utils/slate-utils'
 import {SLATE_TO_PORTABLE_TEXT_RANGE} from '../../internal-utils/weakMaps'
 import type {EditorSelection, PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
-import type {RelayActor} from '../relay-machine'
 
 const debug = debugWithName('plugin:withPortableTextSelections')
 const debugVerbose = debug.enabled && false
@@ -12,7 +11,6 @@ const debugVerbose = debug.enabled && false
 // This plugin will make sure that we emit a PT selection whenever the editor has changed.
 export function createWithPortableTextSelections(
   editorActor: EditorActor,
-  relayActor: RelayActor,
 ): (editor: PortableTextSlateEditor) => PortableTextSlateEditor {
   let prevSelection: BaseRange | null = null
   return function withPortableTextSelections(
@@ -42,9 +40,9 @@ export function createWithPortableTextSelections(
           )
         }
         if (ptRange) {
-          relayActor.send({type: 'selection', selection: ptRange})
+          editorActor.send({type: 'update selection', selection: ptRange})
         } else {
-          relayActor.send({type: 'selection', selection: null})
+          editorActor.send({type: 'update selection', selection: null})
         }
       }
       prevSelection = editor.selection

package/src/editor/plugins/with-plugins.ts

@@ -58,10 +58,8 @@ export const withPlugins = <T extends Editor>(
   const withUtils = createWithUtils({
     editorActor,
   })
-  const withPortableTextSelections = createWithPortableTextSelections(
-    editorActor,
-    relayActor,
-  )
+  const withPortableTextSelections =
+    createWithPortableTextSelections(editorActor)
   const withEventListeners = createWithEventListeners(editorActor)
 
   // Ordering is important here, selection dealing last, data manipulation in the middle and core model stuff first.