@portabletext/editor 1.44.14 → 1.44.16

package/src/behaviors/behavior.default.ts

@@ -1,5 +1,7 @@
+import type {ConverterEvent} from '../converters/converter.types'
 import {isTextBlock} from '../internal-utils/parse-blocks'
 import * as selectors from '../selectors'
+import type {PickFromUnion} from '../type-utils'
 import {getTextBlockText} from '../utils'
 import {abstractAnnotationBehaviors} from './behavior.abstract.annotation'
 import {abstractDecoratorBehaviors} from './behavior.abstract.decorator'
@@ -15,44 +17,44 @@ import {defineBehavior} from './behavior.types.behavior'
 const raiseDeserializationSuccessOrFailure = defineBehavior({
   on: 'deserialize',
   guard: ({snapshot, event}) => {
-    const deserializeEvents = snapshot.context.converters.flatMap(
-      (converter) => {
-        const data = event.originEvent.originEvent.dataTransfer.getData(
-          converter.mimeType,
-        )
+    let success:
+      | PickFromUnion<ConverterEvent, 'type', 'deserialization.success'>
+      | undefined
+    const failures: Array<
+      PickFromUnion<ConverterEvent, 'type', 'deserialization.failure'>
+    > = []
 
-        if (!data) {
-          return []
-        }
+    for (const converter of snapshot.context.converters) {
+      const data = event.originEvent.originEvent.dataTransfer.getData(
+        converter.mimeType,
+      )
 
-        return [
-          converter.deserialize({
-            snapshot,
-            event: {type: 'deserialize', data},
-          }),
-        ]
-      },
-    )
+      if (!data) {
+        continue
+      }
 
-    const firstSuccess = deserializeEvents.find(
-      (deserializeEvent) => deserializeEvent.type === 'deserialization.success',
-    )
+      const deserializeEvent = converter.deserialize({
+        snapshot,
+        event: {type: 'deserialize', data},
+      })
+
+      if (deserializeEvent.type === 'deserialization.success') {
+        success = deserializeEvent
+        break
+      } else {
+        failures.push(deserializeEvent)
+      }
+    }
 
-    if (!firstSuccess) {
+    if (!success) {
       return {
         type: 'deserialization.failure',
         mimeType: '*/*',
-        reason: deserializeEvents
-          .map((deserializeEvent) =>
-            deserializeEvent.type === 'deserialization.failure'
-              ? deserializeEvent.reason
-              : '',
-          )
-          .join(', '),
+        reason: failures.map((failure) => failure.reason).join(', '),
       } as const
     }
 
-    return firstSuccess
+    return success
   },
   actions: [
     ({event}, deserializeEvent) => [

package/src/behaviors/behavior.types.event.ts

@@ -73,13 +73,12 @@ const syntheticBehaviorEventTypes = [
   'history.redo',
   'history.undo',
   'insert.inline object',
-  'insert.break',
-  'insert.soft break',
   'insert.block',
   'insert.span',
   'insert.text',
   'move.block',
   'select',
+  'split.block',
 ] as const
 
 type SyntheticBehaviorEventType = (typeof syntheticBehaviorEventTypes)[number]
@@ -163,12 +162,6 @@ export type SyntheticBehaviorEvent =
         value?: {[prop: string]: unknown}
       }
     }
-  | {
-      type: StrictExtract<SyntheticBehaviorEventType, 'insert.break'>
-    }
-  | {
-      type: StrictExtract<SyntheticBehaviorEventType, 'insert.soft break'>
-    }
   | {
       type: StrictExtract<SyntheticBehaviorEventType, 'insert.block'>
       block: BlockWithOptionalKey
@@ -197,6 +190,9 @@ export type SyntheticBehaviorEvent =
       type: StrictExtract<SyntheticBehaviorEventType, 'select'>
       selection: EditorSelection
     }
+  | {
+      type: StrictExtract<SyntheticBehaviorEventType, 'split.block'>
+    }
 
 export type InsertPlacement = 'auto' | 'after' | 'before'
 
@@ -217,6 +213,8 @@ const abstractBehaviorEventTypes = [
   'deserialization.success',
   'deserialization.failure',
   'insert.blocks',
+  'insert.break',
+  'insert.soft break',
   'list item.add',
   'list item.remove',
   'list item.toggle',
@@ -317,6 +315,12 @@ export type AbstractBehaviorEvent =
       blocks: Array<PortableTextBlock>
       placement: InsertPlacement
     }
+  | {
+      type: StrictExtract<AbstractBehaviorEventType, 'insert.break'>
+    }
+  | {
+      type: StrictExtract<AbstractBehaviorEventType, 'insert.soft break'>
+    }
   | {
       type: StrictExtract<AbstractBehaviorEventType, 'list item.add'>
       listItem: string

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

@@ -1,5 +1,5 @@
 import {Editor} from 'slate'
-import {insertSoftBreakActionImplementation} from '../../behavior-actions/behavior.action.insert-break'
+import {insertTextActionImplementation} from '../../behavior-actions/behavior.action.insert.text'
 import {performAction} from '../../behavior-actions/behavior.actions'
 import {slateRangeToSelection} from '../../internal-utils/slate-utils'
 import type {EditorActor} from '../editor-machine'
@@ -83,12 +83,12 @@ export function createWithEventListeners(editorActor: EditorActor) {
 
     editor.insertSoftBreak = () => {
       if (isApplyingBehaviorActions(editor)) {
-        insertSoftBreakActionImplementation({
+        insertTextActionImplementation({
           context: {
             keyGenerator: editorActor.getSnapshot().context.keyGenerator,
             schema: editorActor.getSnapshot().context.schema,
           },
-          action: {type: 'insert.soft break', editor},
+          action: {type: 'insert.text', text: '\n', editor},
         })
         return
       }

package/src/plugins/plugin.one-line.tsx

@@ -23,6 +23,13 @@ const oneLineBehaviors = [
     on: 'insert.break',
     actions: [() => [{type: 'noop'}]],
   }),
+  /**
+   * `split.block`s as well.
+   */
+  defineBehavior({
+    on: 'split.block',
+    actions: [() => [{type: 'noop'}]],
+  }),
   /**
    * `insert.block` `before` or `after` is not allowed in a one-line editor.
    */