@portabletext/editor 1.27.0 → 1.30.0

package/lib/utils/index.js

@@ -1,7 +1,73 @@
 import { blockOffsetToSpanSelectionPoint, getTextBlockText, isEmptyTextBlock, spanSelectionPointToBlockOffset } from "../_chunks-es/util.is-empty-text-block.js";
 import { getBlockEndPoint, getBlockStartPoint, isEqualSelectionPoints, isKeyedSegment } from "../_chunks-es/util.is-equal-selection-points.js";
+import { parseBlock } from "../_chunks-es/parse-blocks.js";
 import { reverseSelection } from "../_chunks-es/util.reverse-selection.js";
 import { sliceBlocks } from "../_chunks-es/util.slice-blocks.js";
+function isSpan(context, child) {
+  return child._type === context.schema.span.name;
+}
+function isTextBlock(context, block) {
+  return block._type === context.schema.block.name;
+}
+function mergeTextBlocks({
+  context,
+  targetBlock,
+  incomingBlock
+}) {
+  const parsedIncomingBlock = parseBlock({
+    context,
+    block: incomingBlock,
+    options: {
+      refreshKeys: !0
+    }
+  });
+  return !parsedIncomingBlock || !isTextBlock(context, parsedIncomingBlock) ? targetBlock : {
+    ...targetBlock,
+    children: [...targetBlock.children, ...parsedIncomingBlock.children],
+    markDefs: [...targetBlock.markDefs ?? [], ...parsedIncomingBlock.markDefs ?? []]
+  };
+}
+function splitTextBlock({
+  context,
+  block,
+  point
+}) {
+  const firstChild = block.children.at(0), lastChild = block.children.at(block.children.length - 1);
+  if (!firstChild || !lastChild)
+    return;
+  const before = sliceBlocks({
+    blocks: [block],
+    selection: {
+      anchor: {
+        path: [{
+          _key: block._key
+        }, "children", {
+          _key: firstChild._key
+        }],
+        offset: 0
+      },
+      focus: point
+    }
+  }).at(0), after = sliceBlocks({
+    blocks: [block],
+    selection: {
+      anchor: point,
+      focus: {
+        path: [{
+          _key: block._key
+        }, "children", {
+          _key: lastChild._key
+        }],
+        offset: isSpan(context, lastChild) ? lastChild.text.length : 0
+      }
+    }
+  }).at(0);
+  if (!(!before || !after) && !(!isTextBlock(context, before) || !isTextBlock(context, after)))
+    return {
+      before,
+      after
+    };
+}
 export {
   blockOffsetToSpanSelectionPoint,
   getBlockEndPoint,
@@ -10,8 +76,12 @@ export {
   isEmptyTextBlock,
   isEqualSelectionPoints,
   isKeyedSegment,
+  isSpan,
+  isTextBlock,
+  mergeTextBlocks,
   reverseSelection,
   sliceBlocks,
-  spanSelectionPointToBlockOffset
+  spanSelectionPointToBlockOffset,
+  splitTextBlock
 };
 //# sourceMappingURL=index.js.map

package/lib/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}
+{"version":3,"file":"index.js","sources":["../../src/utils/util.is-span.ts","../../src/utils/util.is-text-block.ts","../../src/utils/util.merge-text-blocks.ts","../../src/utils/util.split-text-block.ts"],"sourcesContent":["import type {PortableTextChild, PortableTextSpan} from '@sanity/types'\nimport type {EditorContext} from '../selectors'\n\n/**\n * @public\n */\nexport function isSpan(\n  context: Pick<EditorContext, 'schema'>,\n  child: PortableTextChild,\n): child is PortableTextSpan {\n  return child._type === context.schema.span.name\n}\n","import type {PortableTextBlock, PortableTextTextBlock} from '@sanity/types'\nimport type {EditorContext} from '../selectors'\n\n/**\n * @public\n */\nexport function isTextBlock(\n  context: Pick<EditorContext, 'schema'>,\n  block: PortableTextBlock,\n): block is PortableTextTextBlock {\n  return block._type === context.schema.block.name\n}\n","import type {PortableTextTextBlock} from '@sanity/types'\nimport {parseBlock} from '../internal-utils/parse-blocks'\nimport type {EditorContext} from '../selectors'\nimport {isTextBlock} from './util.is-text-block'\n\n/**\n * @beta\n */\nexport function mergeTextBlocks({\n  context,\n  targetBlock,\n  incomingBlock,\n}: {\n  context: Pick<EditorContext, 'keyGenerator' | 'schema'>\n  targetBlock: PortableTextTextBlock\n  incomingBlock: PortableTextTextBlock\n}) {\n  const parsedIncomingBlock = parseBlock({\n    context,\n    block: incomingBlock,\n    options: {refreshKeys: true},\n  })\n\n  if (!parsedIncomingBlock || !isTextBlock(context, parsedIncomingBlock)) {\n    return targetBlock\n  }\n\n  return {\n    ...targetBlock,\n    children: [...targetBlock.children, ...parsedIncomingBlock.children],\n    markDefs: [\n      ...(targetBlock.markDefs ?? []),\n      ...(parsedIncomingBlock.markDefs ?? []),\n    ],\n  }\n}\n","import type {PortableTextTextBlock} from '@sanity/types'\nimport {isTextBlock, sliceBlocks, type EditorSelectionPoint} from '.'\nimport type {EditorContext} from '../selectors'\nimport {isSpan} from './util.is-span'\n\n/**\n * @beta\n */\nexport function splitTextBlock({\n  context,\n  block,\n  point,\n}: {\n  context: Pick<EditorContext, 'schema'>\n  block: PortableTextTextBlock\n  point: EditorSelectionPoint\n}): {before: PortableTextTextBlock; after: PortableTextTextBlock} | undefined {\n  const firstChild = block.children.at(0)\n  const lastChild = block.children.at(block.children.length - 1)\n\n  if (!firstChild || !lastChild) {\n    return undefined\n  }\n\n  const before = sliceBlocks({\n    blocks: [block],\n    selection: {\n      anchor: {\n        path: [{_key: block._key}, 'children', {_key: firstChild._key}],\n        offset: 0,\n      },\n      focus: point,\n    },\n  }).at(0)\n  const after = sliceBlocks({\n    blocks: [block],\n    selection: {\n      anchor: point,\n      focus: {\n        path: [{_key: block._key}, 'children', {_key: lastChild._key}],\n        offset: isSpan(context, lastChild) ? lastChild.text.length : 0,\n      },\n    },\n  }).at(0)\n\n  if (!before || !after) {\n    return undefined\n  }\n\n  if (!isTextBlock(context, before) || !isTextBlock(context, after)) {\n    return undefined\n  }\n\n  return {before, after}\n}\n"],"names":["isSpan","context","child","_type","schema","span","name","isTextBlock","block","mergeTextBlocks","targetBlock","incomingBlock","parsedIncomingBlock","parseBlock","options","refreshKeys","children","markDefs","splitTextBlock","point","firstChild","at","lastChild","length","before","sliceBlocks","blocks","selection","anchor","path","_key","offset","focus","after","text"],"mappings":";;;;;AAMgBA,SAAAA,OACdC,SACAC,OAC2B;AAC3B,SAAOA,MAAMC,UAAUF,QAAQG,OAAOC,KAAKC;AAC7C;ACLgBC,SAAAA,YACdN,SACAO,OACgC;AAChC,SAAOA,MAAML,UAAUF,QAAQG,OAAOI,MAAMF;AAC9C;ACHO,SAASG,gBAAgB;AAAA,EAC9BR;AAAAA,EACAS;AAAAA,EACAC;AAKF,GAAG;AACD,QAAMC,sBAAsBC,WAAW;AAAA,IACrCZ;AAAAA,IACAO,OAAOG;AAAAA,IACPG,SAAS;AAAA,MAACC,aAAa;AAAA,IAAA;AAAA,EAAI,CAC5B;AAED,SAAI,CAACH,uBAAuB,CAACL,YAAYN,SAASW,mBAAmB,IAC5DF,cAGF;AAAA,IACL,GAAGA;AAAAA,IACHM,UAAU,CAAC,GAAGN,YAAYM,UAAU,GAAGJ,oBAAoBI,QAAQ;AAAA,IACnEC,UAAU,CACR,GAAIP,YAAYO,YAAY,CAAA,GAC5B,GAAIL,oBAAoBK,YAAY,CAAG,CAAA;AAAA,EAE3C;AACF;AC3BO,SAASC,eAAe;AAAA,EAC7BjB;AAAAA,EACAO;AAAAA,EACAW;AAKF,GAA8E;AAC5E,QAAMC,aAAaZ,MAAMQ,SAASK,GAAG,CAAC,GAChCC,YAAYd,MAAMQ,SAASK,GAAGb,MAAMQ,SAASO,SAAS,CAAC;AAEzD,MAAA,CAACH,cAAc,CAACE;AAClB;AAGF,QAAME,SAASC,YAAY;AAAA,IACzBC,QAAQ,CAAClB,KAAK;AAAA,IACdmB,WAAW;AAAA,MACTC,QAAQ;AAAA,QACNC,MAAM,CAAC;AAAA,UAACC,MAAMtB,MAAMsB;AAAAA,WAAO,YAAY;AAAA,UAACA,MAAMV,WAAWU;AAAAA,QAAAA,CAAK;AAAA,QAC9DC,QAAQ;AAAA,MACV;AAAA,MACAC,OAAOb;AAAAA,IAAAA;AAAAA,EAEV,CAAA,EAAEE,GAAG,CAAC,GACDY,QAAQR,YAAY;AAAA,IACxBC,QAAQ,CAAClB,KAAK;AAAA,IACdmB,WAAW;AAAA,MACTC,QAAQT;AAAAA,MACRa,OAAO;AAAA,QACLH,MAAM,CAAC;AAAA,UAACC,MAAMtB,MAAMsB;AAAAA,WAAO,YAAY;AAAA,UAACA,MAAMR,UAAUQ;AAAAA,QAAAA,CAAK;AAAA,QAC7DC,QAAQ/B,OAAOC,SAASqB,SAAS,IAAIA,UAAUY,KAAKX,SAAS;AAAA,MAAA;AAAA,IAC/D;AAAA,EACF,CACD,EAAEF,GAAG,CAAC;AAEP,MAAI,EAACG,CAAAA,UAAU,CAACS,UAIZ,EAAC1B,CAAAA,YAAYN,SAASuB,MAAM,KAAK,CAACjB,YAAYN,SAASgC,KAAK;AAIzD,WAAA;AAAA,MAACT;AAAAA,MAAQS;AAAAA,IAAK;AACvB;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "1.27.0",
+  "version": "1.30.0",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -34,7 +34,7 @@
       "default": "./lib/index.js"
     },
     "./behaviors": {
-      "source": "./src/behaviors/index.ts",
+      "source": "./src/behaviors/_exports/index.ts",
       "import": "./lib/behaviors/index.js",
       "require": "./lib/behaviors/index.cjs",
       "default": "./lib/behaviors/index.js"
@@ -75,7 +75,7 @@
     "lodash.startcase": "^4.4.0",
     "react-compiler-runtime": "19.0.0-beta-27714ef-20250124",
     "slate": "0.112.0",
-    "slate-dom": "^0.111.0",
+    "slate-dom": "^0.112.2",
     "slate-react": "0.112.1",
     "use-effect-event": "^1.0.2",
     "xstate": "^5.19.2",
@@ -85,7 +85,7 @@
   "devDependencies": {
     "@portabletext/toolkit": "^2.0.16",
     "@sanity/diff-match-patch": "^3.2.0",
-    "@sanity/pkg-utils": "^7.0.3",
+    "@sanity/pkg-utils": "^7.0.4",
     "@sanity/schema": "^3.72.1",
     "@sanity/types": "^3.72.1",
     "@testing-library/jest-dom": "^6.6.3",

package/src/behavior-actions/behavior.action.delete.ts

@@ -0,0 +1,18 @@
+import {deleteFragment, select} from 'slate'
+import {toSlateRange} from '../internal-utils/ranges'
+import type {BehaviorActionImplementation} from './behavior.actions'
+
+export const deleteActionImplementation: BehaviorActionImplementation<
+  'delete'
+> = ({action}) => {
+  const range = toSlateRange(action.selection, action.editor)
+
+  if (!range) {
+    throw new Error(
+      `Failed to get Slate Range for selection ${JSON.stringify(action.selection)}`,
+    )
+  }
+
+  select(action.editor, range)
+  deleteFragment(action.editor)
+}

package/src/behavior-actions/behavior.action.insert-break.ts

@@ -1,5 +1,5 @@
 import {isEqual} from 'lodash'
-import {Editor, Node, Path, Transforms} from 'slate'
+import {Editor, insertText, Node, Path, Transforms} from 'slate'
 import type {SlateTextBlock, VoidElement} from '../types/slate'
 import type {BehaviorActionImplementation} from './behavior.actions'
 
@@ -24,109 +24,119 @@ export const insertBreakActionImplementation: BehaviorActionImplementation<
     const selectionAcrossBlocks = anchorBlockPath[0] !== focusBlockPath[0]
 
     if (!selectionAcrossBlocks) {
-      Editor.withoutNormalizing(editor, () => {
-        if (!editor.selection) {
-          return
-        }
+      Transforms.splitNodes(editor, {
+        at: editor.selection,
+      })
+
+      const [nextBlock, nextBlockPath] = Editor.node(
+        editor,
+        Path.next(focusBlockPath),
+        {depth: 1},
+      )
 
-        Transforms.splitNodes(editor, {
-          at: editor.selection,
-        })
+      const nextChild = Node.child(nextBlock, 0)
+      const firstChildIsInlineObject = !editor.isTextSpan(nextChild)
 
-        const [nextNode, nextNodePath] = Editor.node(
+      if (firstChildIsInlineObject) {
+        // If the first child in the next block is an inline object then we
+        // add an empty span right before it to a place to put the cursor.
+        // This is a Slate constraint that we have to adhere to.
+        Transforms.insertNodes(
           editor,
-          Path.next(focusBlockPath),
-          {depth: 1},
+          {
+            _key: context.keyGenerator(),
+            _type: 'span',
+            text: '',
+            marks: [],
+          },
+          {
+            at: [nextBlockPath[0], 0],
+          },
         )
+      }
 
-        Transforms.setSelection(editor, {
-          anchor: {path: [...nextNodePath, 0], offset: 0},
-          focus: {path: [...nextNodePath, 0], offset: 0},
-        })
-
-        /**
-         * Assign new keys to markDefs that are now split across two blocks
-         */
-        if (
-          editor.isTextBlock(nextNode) &&
-          nextNode.markDefs &&
-          nextNode.markDefs.length > 0
-        ) {
-          const newMarkDefKeys = new Map<string, string>()
-
-          const prevNodeSpans = Array.from(
-            Node.children(editor, focusBlockPath),
-          )
-            .map((entry) => entry[0])
-            .filter((node) => editor.isTextSpan(node))
-          const children = Node.children(editor, nextNodePath)
+      Transforms.setSelection(editor, {
+        anchor: {path: [...nextBlockPath, 0], offset: 0},
+        focus: {path: [...nextBlockPath, 0], offset: 0},
+      })
 
-          for (const [child, childPath] of children) {
-            if (!editor.isTextSpan(child)) {
-              continue
-            }
+      /**
+       * Assign new keys to markDefs that are now split across two blocks
+       */
+      if (
+        editor.isTextBlock(nextBlock) &&
+        nextBlock.markDefs &&
+        nextBlock.markDefs.length > 0
+      ) {
+        const newMarkDefKeys = new Map<string, string>()
+
+        const prevNodeSpans = Array.from(Node.children(editor, focusBlockPath))
+          .map((entry) => entry[0])
+          .filter((node) => editor.isTextSpan(node))
+        const children = Node.children(editor, nextBlockPath)
+
+        for (const [child, childPath] of children) {
+          if (!editor.isTextSpan(child)) {
+            continue
+          }
 
-            const marks = child.marks ?? []
-
-            // Go through the marks of the span and figure out if any of
-            // them refer to annotations that are also present in the
-            // previous block
-            for (const mark of marks) {
-              if (
-                schema.decorators.some((decorator) => decorator.value === mark)
-              ) {
-                continue
-              }
-
-              if (
-                prevNodeSpans.some((prevNodeSpan) =>
-                  prevNodeSpan.marks?.includes(mark),
-                ) &&
-                !newMarkDefKeys.has(mark)
-              ) {
-                // This annotation is both present in the previous block
-                // and this block, so let's assign a new key to it
-                newMarkDefKeys.set(mark, keyGenerator())
-              }
-            }
+          const marks = child.marks ?? []
 
-            const newMarks = marks.map(
-              (mark) => newMarkDefKeys.get(mark) ?? mark,
-            )
+          // Go through the marks of the span and figure out if any of
+          // them refer to annotations that are also present in the
+          // previous block
+          for (const mark of marks) {
+            if (
+              schema.decorators.some((decorator) => decorator.value === mark)
+            ) {
+              continue
+            }
 
-            // No need to update the marks if they are the same
-            if (!isEqual(marks, newMarks)) {
-              Transforms.setNodes(
-                editor,
-                {marks: newMarks},
-                {
-                  at: childPath,
-                },
-              )
+            if (
+              prevNodeSpans.some((prevNodeSpan) =>
+                prevNodeSpan.marks?.includes(mark),
+              ) &&
+              !newMarkDefKeys.has(mark)
+            ) {
+              // This annotation is both present in the previous block
+              // and this block, so let's assign a new key to it
+              newMarkDefKeys.set(mark, keyGenerator())
             }
           }
 
-          // Time to update all the markDefs that need a new key because
-          // they've been split across blocks
-          const newMarkDefs = nextNode.markDefs.map((markDef) => ({
-            ...markDef,
-            _key: newMarkDefKeys.get(markDef._key) ?? markDef._key,
-          }))
+          const newMarks = marks.map((mark) => newMarkDefKeys.get(mark) ?? mark)
 
-          // No need to update the markDefs if they are the same
-          if (!isEqual(nextNode.markDefs, newMarkDefs)) {
+          // No need to update the marks if they are the same
+          if (!isEqual(marks, newMarks)) {
             Transforms.setNodes(
               editor,
-              {markDefs: newMarkDefs},
+              {marks: newMarks},
               {
-                at: nextNodePath,
-                match: (node) => editor.isTextBlock(node),
+                at: childPath,
               },
             )
           }
         }
-      })
-      editor.onChange()
+
+        // Time to update all the markDefs that need a new key because
+        // they've been split across blocks
+        const newMarkDefs = nextBlock.markDefs.map((markDef) => ({
+          ...markDef,
+          _key: newMarkDefKeys.get(markDef._key) ?? markDef._key,
+        }))
+
+        // No need to update the markDefs if they are the same
+        if (!isEqual(nextBlock.markDefs, newMarkDefs)) {
+          Transforms.setNodes(
+            editor,
+            {markDefs: newMarkDefs},
+            {
+              at: nextBlockPath,
+              match: (node) => editor.isTextBlock(node),
+            },
+          )
+        }
+      }
       return
     }
   }
@@ -136,11 +146,6 @@ export const insertBreakActionImplementation: BehaviorActionImplementation<
 
 export const insertSoftBreakActionImplementation: BehaviorActionImplementation<
   'insert.soft break'
-> = ({context, action}) => {
-  // This mimics Slate's internal which also just does a regular insert break
-  // when soft-breaking
-  insertBreakActionImplementation({
-    context,
-    action: {...action, type: 'insert.break'},
-  })
+> = ({action}) => {
+  insertText(action.editor, '\n')
 }

package/src/behavior-actions/behavior.actions.ts

@@ -31,6 +31,7 @@ import {insertBlock} from './behavior.action-utils.insert-block'
 import {blockSetBehaviorActionImplementation} from './behavior.action.block.set'
 import {blockUnsetBehaviorActionImplementation} from './behavior.action.block.unset'
 import {dataTransferSetActionImplementation} from './behavior.action.data-transfer-set'
+import {deleteActionImplementation} from './behavior.action.delete'
 import {insertBlockObjectActionImplementation} from './behavior.action.insert-block-object'
 import {insertBlocksActionImplementation} from './behavior.action.insert-blocks'
 import {
@@ -89,6 +90,7 @@ const behaviorActionImplementations: BehaviorActionImplementations = {
   'focus': ({action}) => {
     ReactEditor.focus(action.editor)
   },
+  'delete': deleteActionImplementation,
   'delete.backward': ({action}) => {
     deleteBackward(action.editor, action.unit)
   },
@@ -412,6 +414,13 @@ function performDefaultAction({
       })
       break
     }
+    case 'delete': {
+      behaviorActionImplementations.delete({
+        context,
+        action,
+      })
+      break
+    }
     case 'delete.backward': {
       behaviorActionImplementations['delete.backward']({
         context,

package/src/behaviors/_exports/index.ts

@@ -0,0 +1 @@
+export * from '../index'

package/src/behaviors/behavior.core.deserialize.ts

@@ -1,46 +1,60 @@
 import {defineBehavior, raise} from './behavior.types'
 
-export const coreDeserializeBehavior = defineBehavior({
-  on: 'deserialize',
-  guard: ({context, event}) => {
-    const deserializeEvents = context.converters.flatMap((converter) => {
-      const data = event.dataTransfer.getData(converter.mimeType)
+export const coreDeserializeBehaviors = {
+  'deserialize': defineBehavior({
+    on: 'deserialize',
+    guard: ({context, event}) => {
+      const deserializeEvents = context.converters.flatMap((converter) => {
+        const data = event.dataTransfer.getData(converter.mimeType)
 
-      if (!data) {
-        return []
-      }
+        if (!data) {
+          return []
+        }
 
-      return [
-        converter.deserialize({context, event: {type: 'deserialize', data}}),
-      ]
-    })
+        return [
+          converter.deserialize({context, event: {type: 'deserialize', data}}),
+        ]
+      })
 
-    const firstSuccess = deserializeEvents.find(
-      (deserializeEvent) => deserializeEvent.type === 'deserialization.success',
-    )
+      const firstSuccess = deserializeEvents.find(
+        (deserializeEvent) =>
+          deserializeEvent.type === 'deserialization.success',
+      )
 
-    if (!firstSuccess) {
-      return {
-        type: 'deserialization.failure',
-        mimeType: '*/*',
-        reason: deserializeEvents
-          .map((deserializeEvent) =>
-            deserializeEvent.type === 'deserialization.failure'
-              ? deserializeEvent.reason
-              : '',
-          )
-          .join(', '),
-      } as const
-    }
+      if (!firstSuccess) {
+        return {
+          type: 'deserialization.failure',
+          mimeType: '*/*',
+          reason: deserializeEvents
+            .map((deserializeEvent) =>
+              deserializeEvent.type === 'deserialization.failure'
+                ? deserializeEvent.reason
+                : '',
+            )
+            .join(', '),
+        } as const
+      }
 
-    return firstSuccess
-  },
-  actions: [
-    ({event}, deserializeEvent) => [
-      raise({
-        ...deserializeEvent,
-        dataTransfer: event.dataTransfer,
-      }),
+      return firstSuccess
+    },
+    actions: [
+      ({event}, deserializeEvent) => [
+        raise({
+          ...deserializeEvent,
+          dataTransfer: event.dataTransfer,
+        }),
+      ],
+    ],
+  }),
+  'deserialization.success': defineBehavior({
+    on: 'deserialization.success',
+    actions: [
+      ({event}) => [
+        raise({
+          type: 'insert.blocks',
+          blocks: event.data,
+        }),
+      ],
     ],
-  ],
-})
+  }),
+}

package/src/behaviors/behavior.core.ts

@@ -1,23 +1,16 @@
 import {coreAnnotationBehaviors} from './behavior.core.annotations'
 import {coreBlockObjectBehaviors} from './behavior.core.block-objects'
 import {coreDecoratorBehaviors} from './behavior.core.decorators'
-import {coreDeserializeBehavior} from './behavior.core.deserialize'
+import {coreDeserializeBehaviors} from './behavior.core.deserialize'
 import {coreInsertBreakBehaviors} from './behavior.core.insert-break'
 import {coreListBehaviors} from './behavior.core.lists'
 import {coreSerializeBehaviors} from './behavior.core.serialize'
 import {coreStyleBehaviors} from './behavior.core.style'
-import {defineBehavior, raise} from './behavior.types'
-
-const softReturn = defineBehavior({
-  on: 'insert.soft break',
-  actions: [() => [raise({type: 'insert.text', text: '\n'})]],
-})
 
 /**
  * @beta
  */
 export const coreBehaviors = [
-  softReturn,
   coreAnnotationBehaviors.toggleAnnotationOff,
   coreAnnotationBehaviors.toggleAnnotationOn,
   coreDecoratorBehaviors.toggleDecoratorOff,
@@ -26,7 +19,8 @@ export const coreBehaviors = [
   coreDecoratorBehaviors.emShortcut,
   coreDecoratorBehaviors.underlineShortcut,
   coreDecoratorBehaviors.codeShortcut,
-  coreDeserializeBehavior,
+  coreDeserializeBehaviors.deserialize,
+  coreDeserializeBehaviors['deserialization.success'],
   coreBlockObjectBehaviors.arrowDownOnLonelyBlockObject,
   coreBlockObjectBehaviors.arrowUpOnLonelyBlockObject,
   coreBlockObjectBehaviors.breakingBlockObject,
@@ -51,10 +45,9 @@ export const coreBehaviors = [
  * @beta
  */
 export const coreBehavior = {
-  softReturn,
   annotation: coreAnnotationBehaviors,
   decorators: coreDecoratorBehaviors,
-  deserialize: coreDeserializeBehavior,
+  deserialize: coreDeserializeBehaviors,
   blockObjects: coreBlockObjectBehaviors,
   insertBreak: coreInsertBreakBehaviors,
   lists: coreListBehaviors,

package/src/behaviors/behavior.types.ts

@@ -66,6 +66,10 @@ export type SyntheticBehaviorEvent =
       type: 'decorator.toggle'
       decorator: string
     }
+  | {
+      type: 'delete'
+      selection: NonNullable<EditorSelection>
+    }
   | {
       type: 'delete.backward'
       unit: TextUnit