@portabletext/editor 1.44.0 → 1.44.2

package/src/editor/create-editor.ts

@@ -12,11 +12,7 @@ import {
   type Snapshot,
 } from 'xstate'
 import type {Behavior} from '../behaviors/behavior.types.behavior'
-import type {
-  CustomBehaviorEvent,
-  ExternalBehaviorEvent,
-  SyntheticBehaviorEvent,
-} from '../behaviors/behavior.types.event'
+import type {ExternalBehaviorEvent} from '../behaviors/behavior.types.event'
 import {coreConverters} from '../converters/converters.core'
 import {compileType} from '../internal-utils/schema'
 import type {EditableAPI} from '../types/editor'
@@ -63,11 +59,7 @@ export type EditorConfig = {
 /**
  * @public
  */
-export type EditorEvent =
-  | ExternalEditorEvent
-  | ExternalBehaviorEvent
-  | SyntheticBehaviorEvent
-  | CustomBehaviorEvent
+export type EditorEvent = ExternalEditorEvent | ExternalBehaviorEvent
 
 /**
  * @public
@@ -154,7 +146,41 @@ function createInternalEditorFromActor(
       }
     },
     send: (event) => {
-      editorActor.send(event)
+      switch (event.type) {
+        case 'add behavior':
+        case 'remove behavior':
+        case 'update behaviors':
+        case 'update key generator':
+        case 'update readOnly':
+        case 'patches':
+        case 'update value':
+        case 'update schema':
+        case 'update maxBlocks':
+          editorActor.send(event)
+          break
+
+        case 'insert.block object':
+          editorActor.send({
+            type: 'behavior event',
+            behaviorEvent: {
+              type: 'insert.block',
+              block: {
+                _type: event.blockObject.name,
+                ...(event.blockObject.value ?? {}),
+              },
+              placement: event.placement,
+            },
+            editor: slateEditor.instance,
+          })
+          break
+
+        default:
+          editorActor.send({
+            type: 'behavior event',
+            behaviorEvent: event,
+            editor: slateEditor.instance,
+          })
+      }
     },
     on: (event, listener) => {
       const subscription = editorActor.on(event, (event) => {

package/src/editor/editor-machine.ts

@@ -13,13 +13,7 @@ import {coreBehaviors} from '../behaviors/behavior.core'
 import {defaultBehaviors} from '../behaviors/behavior.default'
 import {performEvent} from '../behaviors/behavior.perform-event'
 import type {Behavior} from '../behaviors/behavior.types.behavior'
-import type {
-  CustomBehaviorEvent,
-  ExternalBehaviorEvent,
-  InternalBehaviorEvent,
-  NativeBehaviorEvent,
-  SyntheticBehaviorEvent,
-} from '../behaviors/behavior.types.event'
+import type {BehaviorEvent} from '../behaviors/behavior.types.event'
 import type {Converter} from '../converters/converter.types'
 import type {EventPosition} from '../internal-utils/event-position'
 import type {NamespaceEvent} from '../type-utils'
@@ -167,6 +161,7 @@ export type HasTag = ReturnType<EditorActor['getSnapshot']>['hasTag']
  * @internal
  */
 export type InternalEditorEvent =
+  | ExternalEditorEvent
   | {
       type: 'normalizing'
     }
@@ -178,28 +173,15 @@ export type InternalEditorEvent =
     }
   | {
       type: 'behavior event'
-      behaviorEvent:
-        | InternalBehaviorEvent
-        | SyntheticBehaviorEvent
-        | NativeBehaviorEvent
+      behaviorEvent: BehaviorEvent
       editor: PortableTextSlateEditor
       defaultActionCallback?: () => void
       nativeEvent?: {preventDefault: () => void}
     }
-  | {
-      type: 'custom behavior event'
-      behaviorEvent: CustomBehaviorEvent
-      editor: PortableTextSlateEditor
-      nativeEvent?: {preventDefault: () => void}
-    }
-  | CustomBehaviorEvent
-  | ExternalBehaviorEvent
-  | ExternalEditorEvent
   | MutationEvent
   | InternalPatchEvent
   | NamespaceEvent<EditorEmittedEvent, 'notify'>
   | NamespaceEvent<UnsetEvent, 'notify'>
-  | SyntheticBehaviorEvent
   | {
       type: 'dragstart'
       origin: Pick<EventPosition, 'selection'>
@@ -213,15 +195,9 @@ export type InternalEditorEvent =
  */
 export type InternalEditorEmittedEvent =
   | EditorEmittedEvent
-  | ExternalBehaviorEvent
   | InternalPatchEvent
   | PatchesEvent
   | UnsetEvent
-  | {
-      type: 'custom.*'
-      event: CustomBehaviorEvent
-    }
-  | SyntheticBehaviorEvent
 
 /**
  * @internal
@@ -318,7 +294,7 @@ export const editorMachine = setup({
       pendingEvents: [],
     }),
     'handle behavior event': ({context, event, self}) => {
-      assertEvent(event, ['behavior event', 'custom behavior event'])
+      assertEvent(event, ['behavior event'])
 
       performEvent({
         behaviors: [...context.behaviors.values(), ...defaultBehaviors],
@@ -447,54 +423,6 @@ export const editorMachine = setup({
             'behavior event': {
               actions: 'handle behavior event',
             },
-            'custom behavior event': {
-              actions: 'handle behavior event',
-            },
-            'annotation.*': {
-              actions: emit(({event}) => event),
-            },
-            'block.*': {
-              actions: emit(({event}) => event),
-            },
-            'blur': {
-              actions: emit(({event}) => event),
-            },
-            'custom.*': {
-              actions: emit(({event}) => ({type: 'custom.*', event})),
-            },
-            'decorator.*': {
-              actions: emit(({event}) => event),
-            },
-            'delete.*': {
-              actions: emit(({event}) => event),
-            },
-            'focus': {
-              actions: emit(({event}) => event),
-            },
-            'history.*': {
-              actions: emit(({event}) => event),
-            },
-            'insert.*': {
-              actions: emit(({event}) => event),
-            },
-            'list item.*': {
-              actions: emit(({event}) => event),
-            },
-            'move.*': {
-              actions: emit(({event}) => event),
-            },
-            'select': {
-              actions: emit(({event}) => event),
-            },
-            'select.*': {
-              actions: emit(({event}) => event),
-            },
-            'style.*': {
-              actions: emit(({event}) => event),
-            },
-            'text block.*': {
-              actions: emit(({event}) => event),
-            },
           },
           initial: 'idle',
           states: {

package/src/editor/editor-selector.ts

@@ -1,10 +1,10 @@
 import {useSelector} from '@xstate/react'
+import {slateChildrenToBlocks} from '../internal-utils/slate-children-to-blocks'
 import type {PortableTextSlateEditor} from '../types/editor'
 import type {Editor, InternalEditor} from './create-editor'
 import type {EditorActor} from './editor-machine'
 import type {EditorSnapshot} from './editor-snapshot'
 import {getActiveDecorators} from './get-active-decorators'
-import {getValue} from './get-value'
 
 function defaultCompare<T>(a: T, b: T) {
   return a === b
@@ -77,7 +77,10 @@ export function getEditorSnapshot({
       readOnly: editorActorSnapshot.matches({'edit mode': 'read only'}),
       schema: editorActorSnapshot.context.schema,
       selection: editorActorSnapshot.context.selection,
-      value: getValue({editorActorSnapshot, slateEditorInstance}),
+      value: slateChildrenToBlocks(
+        editorActorSnapshot.context.schema,
+        slateEditorInstance.children,
+      ),
     },
     beta: {
       hasTag: (tag) => editorActorSnapshot.hasTag(tag),

package/src/editor/editor-snapshot.ts

@@ -2,8 +2,7 @@ import type {PortableTextBlock} from '@sanity/types'
 import type {Converter} from '../converters/converter.types'
 import type {EventPosition} from '../internal-utils/event-position'
 import {toPortableTextRange} from '../internal-utils/ranges'
-import {fromSlateValue} from '../internal-utils/values'
-import {KEY_TO_VALUE_ELEMENT} from '../internal-utils/weakMaps'
+import {slateChildrenToBlocks} from '../internal-utils/slate-children-to-blocks'
 import type {EditorSelection, PortableTextSlateEditor} from '../types/editor'
 import type {EditorSchema} from './define-schema'
 import type {HasTag} from './editor-machine'
@@ -62,11 +61,7 @@ export function createEditorSnapshot({
       }
     | undefined
 }) {
-  const value = fromSlateValue(
-    editor.children,
-    schema.block.name,
-    KEY_TO_VALUE_ELEMENT.get(editor),
-  )
+  const value = slateChildrenToBlocks(schema, editor.children)
   const selection = toPortableTextRange(value, editor.selection, schema)
 
   const context = {

package/src/editor/plugins/create-with-event-listeners.ts

@@ -7,75 +7,12 @@ import {KEY_TO_VALUE_ELEMENT} from '../../internal-utils/weakMaps'
 import type {EditorActor} from '../editor-machine'
 import {isApplyingBehaviorActions} from '../with-applying-behavior-actions'
 
-export function createWithEventListeners(
-  editorActor: EditorActor,
-  subscriptions: Array<() => () => void>,
-) {
+export function createWithEventListeners(editorActor: EditorActor) {
   return function withEventListeners(editor: Editor) {
     if (editorActor.getSnapshot().context.maxBlocks !== undefined) {
       return editor
     }
 
-    subscriptions.push(() => {
-      const subscription = editorActor.on('*', (event) => {
-        switch (event.type) {
-          // These events are not relevant for Behaviors
-          case 'blurred':
-          case 'done loading':
-          case 'editable':
-          case 'error':
-          case 'focused':
-          case 'invalid value':
-          case 'loading':
-          case 'mutation':
-          case 'patch':
-          case 'internal.patch':
-          case 'patches':
-          case 'read only':
-          case 'ready':
-          case 'selection':
-          case 'value changed':
-          case 'unset':
-            break
-
-          case 'custom.*':
-            editorActor.send({
-              type: 'custom behavior event',
-              behaviorEvent: event.event,
-              editor,
-            })
-            break
-
-          case 'insert.block object':
-            editorActor.send({
-              type: 'behavior event',
-              behaviorEvent: {
-                type: 'insert.block',
-                block: {
-                  _type: event.blockObject.name,
-                  ...(event.blockObject.value ?? {}),
-                },
-                placement: event.placement,
-              },
-              editor,
-            })
-            break
-
-          default:
-            editorActor.send({
-              type: 'behavior event',
-              behaviorEvent: event,
-              editor,
-            })
-            break
-        }
-      })
-
-      return () => {
-        subscription.unsubscribe()
-      }
-    })
-
     const {deleteBackward, deleteForward, insertBreak, insertText, select} =
       editor
 

package/src/editor/plugins/createWithEditableAPI.ts

@@ -899,33 +899,3 @@ export const removeAnnotationActionImplementation: BehaviorActionImplementation<
     }
   }
 }
-
-export const toggleAnnotationActionImplementation: BehaviorActionImplementation<
-  'annotation.toggle',
-  AddedAnnotationPaths | undefined
-> = ({context, action}) => {
-  const isActive = isAnnotationActive({
-    editor: action.editor,
-    annotation: {name: action.annotation.name},
-  })
-
-  if (isActive) {
-    removeAnnotationActionImplementation({
-      context,
-      action: {
-        type: 'annotation.remove',
-        annotation: action.annotation,
-        editor: action.editor,
-      },
-    })
-  } else {
-    return addAnnotationActionImplementation({
-      context,
-      action: {
-        type: 'annotation.add',
-        annotation: action.annotation,
-        editor: action.editor,
-      },
-    })
-  }
-}

package/src/editor/plugins/createWithPortableTextMarkModel.ts

@@ -8,7 +8,6 @@ import {isPortableTextBlock, isPortableTextSpan} from '@portabletext/toolkit'
 import type {PortableTextObject, PortableTextSpan} from '@sanity/types'
 import {isEqual, uniq} from 'lodash'
 import {Editor, Element, Node, Path, Range, Text, Transforms} from 'slate'
-import {decoratorAddActionImplementation} from '../../behavior-actions/behavior.action.decorator.add'
 import type {BehaviorActionImplementation} from '../../behavior-actions/behavior.actions'
 import {debugWithName} from '../../internal-utils/debug'
 import {getNextSpan, getPreviousSpan} from '../../internal-utils/sibling-utils'
@@ -778,31 +777,3 @@ export function isDecoratorActive({
     }.marks || []
   ).includes(decorator)
 }
-
-export const toggleDecoratorActionImplementation: BehaviorActionImplementation<
-  'decorator.toggle'
-> = ({context, action}) => {
-  const isActive = isDecoratorActive({
-    editor: action.editor,
-    decorator: action.decorator,
-  })
-
-  if (isActive) {
-    removeDecoratorActionImplementation({
-      context,
-      action: {
-        type: 'decorator.remove',
-        editor: action.editor,
-        decorator: action.decorator,
-      },
-    })
-  } else {
-    decoratorAddActionImplementation({
-      context,
-      action: {
-        ...action,
-        type: 'decorator.add',
-      },
-    })
-  }
-}

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

@@ -69,10 +69,7 @@ export const withPlugins = <T extends Editor>(
     editorActor,
     schemaTypes,
   )
-  const withEventListeners = createWithEventListeners(
-    editorActor,
-    options.subscriptions,
-  )
+  const withEventListeners = createWithEventListeners(editorActor)
 
   // Ordering is important here, selection dealing last, data manipulation in the middle and core model stuff first.
   return withEventListeners(

package/src/internal-utils/slate-children-to-blocks.ts

@@ -0,0 +1,49 @@
+import type {PortableTextBlock} from '@sanity/types'
+import type {Descendant} from 'slate'
+import type {EditorSchema} from '../editor/define-schema'
+
+export function slateChildrenToBlocks(
+  schema: EditorSchema,
+  value: Array<Descendant>,
+): Array<PortableTextBlock> {
+  const blocks: Array<PortableTextBlock> = new Array(value.length)
+
+  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
+    const descendant = value[blockIndex]
+
+    if (descendant._type !== schema.block.name) {
+      blocks[blockIndex] = {
+        _key: descendant._key,
+        _type: descendant._type,
+        ...('value' in descendant && typeof descendant.value === 'object'
+          ? descendant.value
+          : {}),
+      }
+      continue
+    }
+
+    const children = 'children' in descendant ? descendant.children : []
+    const processedChildren = new Array(children.length)
+
+    for (let childIndex = 0; childIndex < children.length; childIndex++) {
+      const child = children[childIndex]
+      processedChildren[childIndex] =
+        child._type === schema.span.name
+          ? child
+          : {
+              _key: child._key,
+              _type: child._type,
+              ...('value' in child && typeof child.value === 'object'
+                ? child.value
+                : {}),
+            }
+    }
+
+    blocks[blockIndex] = {
+      ...descendant,
+      children: processedChildren,
+    }
+  }
+
+  return blocks
+}

package/src/internal-utils/slate-utils.ts

@@ -12,14 +12,12 @@ export function getFocusBlock({
     return [undefined, undefined]
   }
 
-  const focusBlock = Array.from(
-    Editor.nodes(editor, {
-      at: editor.selection.focus.path.slice(0, 1),
-      match: (n) => !Editor.isEditor(n),
-    }),
-  ).at(0)
-
-  return focusBlock ?? [undefined, undefined]
+  return (
+    Editor.node(editor, editor.selection.focus.path.slice(0, 1)) ?? [
+      undefined,
+      undefined,
+    ]
+  )
 }
 
 export function getFocusChild({

package/src/type-utils.ts

@@ -25,3 +25,5 @@ export type NamespaceEvent<TEvent, TNamespace extends string> = TEvent extends {
         : TEvent[K]
     }
   : never
+
+export type StrictExtract<T, U extends T> = U

package/src/behavior-actions/behavior.action.move.block-down.ts

@@ -1,48 +0,0 @@
-import {Path} from 'slate'
-import {toSlatePath} from '../internal-utils/paths'
-import {toPortableTextRange} from '../internal-utils/ranges'
-import {isKeyedSegment} from '../utils'
-import {moveBlockActionImplementation} from './behavior.action.move.block'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const moveBlockDownActionImplementation: BehaviorActionImplementation<
-  'move.block down'
-> = ({context, action}) => {
-  const at = [toSlatePath(action.at, action.editor)[0]]
-  const to = [Path.next(at)[0]]
-  const selection = toPortableTextRange(
-    action.editor.children,
-    {
-      anchor: {
-        path: to,
-        offset: 0,
-      },
-      focus: {
-        path: to,
-        offset: 0,
-      },
-    },
-    context.schema,
-  )
-
-  const destinationBlockKey = selection
-    ? isKeyedSegment(selection.focus.path[0])
-      ? selection.focus.path[0]._key
-      : undefined
-    : undefined
-
-  if (destinationBlockKey === undefined) {
-    console.error('Could not find destination block key')
-    return
-  }
-
-  moveBlockActionImplementation({
-    context,
-    action: {
-      type: 'move.block',
-      at: action.at,
-      to: [{_key: destinationBlockKey}],
-      editor: action.editor,
-    },
-  })
-}

package/src/behavior-actions/behavior.action.move.block-up.ts

@@ -1,53 +0,0 @@
-import {Path} from 'slate'
-import {toSlatePath} from '../internal-utils/paths'
-import {toPortableTextRange} from '../internal-utils/ranges'
-import {isKeyedSegment} from '../utils'
-import {moveBlockActionImplementation} from './behavior.action.move.block'
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const moveBlockUpActionImplementation: BehaviorActionImplementation<
-  'move.block up'
-> = ({context, action}) => {
-  const at = [toSlatePath(action.at, action.editor)[0]]
-
-  if (!Path.hasPrevious(at)) {
-    return
-  }
-
-  const to = [Path.previous(at)[0]]
-  const selection = toPortableTextRange(
-    action.editor.children,
-    {
-      anchor: {
-        path: to,
-        offset: 0,
-      },
-      focus: {
-        path: to,
-        offset: 0,
-      },
-    },
-    context.schema,
-  )
-
-  const destinationBlockKey = selection
-    ? isKeyedSegment(selection.focus.path[0])
-      ? selection.focus.path[0]._key
-      : undefined
-    : undefined
-
-  if (destinationBlockKey === undefined) {
-    console.error('Could not find destination block key')
-    return
-  }
-
-  moveBlockActionImplementation({
-    context,
-    action: {
-      type: 'move.block',
-      at: action.at,
-      to: [{_key: destinationBlockKey}],
-      editor: action.editor,
-    },
-  })
-}