@portabletext/editor 2.17.0 → 2.17.2

package/lib/plugins/index.d.cts

@@ -1,5 +1,5 @@
 import { Behavior, Editor, EditorEmittedEvent, EditorSchema } from "../_chunks-dts/behavior.types.action.cjs";
-import * as react12 from "react";
+import * as react22 from "react";
 import React from "react";
 /**
  * @beta
@@ -181,7 +181,7 @@ type MarkdownPluginConfig = MarkdownBehaviorsConfig & {
  */
 declare function MarkdownPlugin(props: {
   config: MarkdownPluginConfig;
-}): react12.JSX.Element;
+}): react22.JSX.Element;
 /**
  * @beta
  * Restrict the editor to one line. The plugin takes care of blocking
@@ -192,5 +192,5 @@ declare function MarkdownPlugin(props: {
  *
  * @deprecated Install the plugin from `@portabletext/plugin-one-line`
  */
-declare function OneLinePlugin(): react12.JSX.Element;
+declare function OneLinePlugin(): react22.JSX.Element;
 export { BehaviorPlugin, DecoratorShortcutPlugin, EditorRefPlugin, EventListenerPlugin, MarkdownPlugin, MarkdownPluginConfig, OneLinePlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "2.17.0",
+  "version": "2.17.2",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -76,7 +76,6 @@
     "@portabletext/to-html": "^3.0.0",
     "@xstate/react": "^6.0.0",
     "debug": "^4.4.3",
-    "get-random-values-esm": "^1.0.2",
     "immer": "^10.2.0",
     "lodash": "^4.17.21",
     "lodash.startcase": "^4.4.0",
@@ -85,9 +84,9 @@
     "slate-dom": "^0.118.1",
     "slate-react": "0.118.2",
     "xstate": "^5.23.0",
-    "@portabletext/block-tools": "^3.5.13",
-    "@portabletext/patches": "^1.1.8",
+    "@portabletext/block-tools": "^3.5.14",
     "@portabletext/keyboard-shortcuts": "^1.1.1",
+    "@portabletext/patches": "^1.1.8",
     "@portabletext/schema": "^1.2.0"
   },
   "devDependencies": {
@@ -102,9 +101,9 @@
     "@types/react": "^19.2.0",
     "@types/react-dom": "^19.2.0",
     "@vitejs/plugin-react": "^5.0.4",
-    "@vitest/browser": "^4.0.4",
-    "@vitest/browser-playwright": "^4.0.4",
-    "@vitest/coverage-istanbul": "^4.0.4",
+    "@vitest/browser": "^4.0.5",
+    "@vitest/browser-playwright": "^4.0.5",
+    "@vitest/coverage-istanbul": "^4.0.5",
     "babel-plugin-react-compiler": "1.0.0",
     "eslint": "^9.38.0",
     "eslint-formatter-gha": "^1.6.0",
@@ -116,14 +115,14 @@
     "typescript": "5.9.3",
     "typescript-eslint": "^8.46.1",
     "vite": "^7.1.10",
-    "vitest": "^4.0.4",
+    "vitest": "^4.0.5",
     "vitest-browser-react": "^2.0.2",
-    "@portabletext/sanity-bridge": "1.1.16",
+    "@portabletext/sanity-bridge": "1.1.17",
     "@portabletext/test": "^0.0.0",
     "racejar": "1.3.2"
   },
   "peerDependencies": {
-    "@portabletext/sanity-bridge": "^1.1.16",
+    "@portabletext/sanity-bridge": "^1.1.17",
     "@sanity/schema": "^4.12.0",
     "@sanity/types": "^4.12.0",
     "react": "^18.3 || ^19",

package/src/behaviors/behavior.abstract.delete.ts

@@ -17,19 +17,14 @@ export const abstractDeleteBehaviors = [
   defineBehavior({
     on: 'delete.backward',
     guard: ({snapshot}) => {
-      if (!snapshot.context.selection) {
-        return false
-      }
-
-      return {selection: snapshot.context.selection}
+      return snapshot.context.selection
     },
     actions: [
-      ({event}, {selection}) => [
+      ({event}) => [
         raise({
           type: 'delete',
           direction: 'backward',
           unit: event.unit,
-          at: selection,
         }),
       ],
     ],
@@ -88,19 +83,14 @@ export const abstractDeleteBehaviors = [
   defineBehavior({
     on: 'delete.forward',
     guard: ({snapshot}) => {
-      if (!snapshot.context.selection) {
-        return false
-      }
-
-      return {selection: snapshot.context.selection}
+      return snapshot.context.selection
     },
     actions: [
-      ({event}, {selection}) => [
+      ({event}) => [
         raise({
           type: 'delete',
           direction: 'forward',
           unit: event.unit,
-          at: selection,
         }),
       ],
     ],
@@ -112,18 +102,24 @@ export const abstractDeleteBehaviors = [
         return false
       }
 
+      const at = event.at ?? snapshot.context.selection
+
+      if (!at) {
+        return false
+      }
+
       const nextBlock = getNextBlock({
         ...snapshot,
         context: {
           ...snapshot.context,
-          selection: event.at,
+          selection: at,
         },
       })
       const focusTextBlock = getFocusTextBlock({
         ...snapshot,
         context: {
           ...snapshot.context,
-          selection: event.at,
+          selection: at,
         },
       })
 

package/src/behaviors/behavior.abstract.insert.ts

@@ -1,6 +1,6 @@
+import {isSelectionExpanded} from '../selectors'
 import {getFocusTextBlock} from '../selectors/selector.get-focus-text-block'
 import {getLastBlock} from '../selectors/selector.get-last-block'
-import {isSelectionCollapsed} from '../utils'
 import {getBlockEndPoint} from '../utils/util.get-block-end-point'
 import {getBlockStartPoint} from '../utils/util.get-block-start-point'
 import {isEmptyTextBlock} from '../utils/util.is-empty-text-block'
@@ -473,20 +473,51 @@ export const abstractInsertBehaviors = [
       ],
     ],
   }),
+
+  /**
+   * If there's an expanded selection, then we delete the selection before we
+   * insert the text.
+   */
   defineBehavior({
     on: 'insert.text',
     guard: ({snapshot}) => {
-      const selection = snapshot.context.selection
+      return isSelectionExpanded(snapshot)
+    },
+    actions: [({event}) => [raise({type: 'delete'}), raise(event)]],
+  }),
+
+  /**
+   * If there's no selection, then we select the end of the editor before we
+   * we insert the text.
+   */
+  defineBehavior({
+    on: 'insert.text',
+    guard: ({snapshot}) => {
+      if (snapshot.context.selection) {
+        return false
+      }
+
+      const lastBlok = getLastBlock(snapshot)
 
-      if (!selection || isSelectionCollapsed(selection)) {
+      if (!lastBlok) {
         return false
       }
 
-      return {selection}
+      const endPoint = getBlockEndPoint({
+        context: snapshot.context,
+        block: lastBlok,
+      })
+      return {endPoint}
     },
     actions: [
-      ({event}, {selection}) => [
-        raise({type: 'delete', at: selection}),
+      ({event}, {endPoint}) => [
+        raise({
+          type: 'select',
+          at: {
+            anchor: endPoint,
+            focus: endPoint,
+          },
+        }),
         raise(event),
       ],
     ],

package/src/behaviors/behavior.abstract.split.ts

@@ -1,10 +1,11 @@
 import {isTextBlock} from '@portabletext/schema'
+import {isSelectionExpanded} from '../selectors'
 import {getFocusBlockObject} from '../selectors/selector.get-focus-block-object'
 import {getFocusInlineObject} from '../selectors/selector.get-focus-inline-object'
 import {getFocusTextBlock} from '../selectors/selector.get-focus-text-block'
-import {getSelectedValue} from '../selectors/selector.get-selected-value'
 import {getSelectionEndBlock} from '../selectors/selector.get-selection-end-block'
 import {getSelectionStartBlock} from '../selectors/selector.get-selection-start-block'
+import {isEqualSelectionPoints} from '../utils'
 import {parseBlock} from '../utils/parse-blocks'
 import {getBlockEndPoint} from '../utils/util.get-block-end-point'
 import {getBlockStartPoint} from '../utils/util.get-block-start-point'
@@ -47,115 +48,49 @@ export const abstractSplitBehaviors = [
         return false
       }
 
-      const selectionStartBlock = getSelectionStartBlock(snapshot)
-      const selectionEndBlock = getSelectionEndBlock(snapshot)
-
-      if (!selectionStartBlock || !selectionEndBlock) {
-        return false
-      }
-
-      if (
-        !isTextBlock(snapshot.context, selectionStartBlock.node) &&
-        isTextBlock(snapshot.context, selectionEndBlock.node)
-      ) {
-        return {selection}
-      }
-
-      return false
-    },
-    actions: [(_, {selection}) => [raise({type: 'delete', at: selection})]],
-  }),
-
-  defineBehavior({
-    on: 'split',
-    guard: ({snapshot}) => {
-      const selection = snapshot.context.selection
+      const startPoint = getSelectionStartPoint(selection)
+      const endPoint = getSelectionEndPoint(selection)
 
-      if (!selection || isSelectionCollapsed(selection)) {
+      if (!startPoint || !endPoint) {
         return false
       }
 
-      const selectionStartBlock = getSelectionStartBlock(snapshot)
-      const selectionEndBlock = getSelectionEndBlock(snapshot)
-
-      if (!selectionStartBlock || !selectionEndBlock) {
-        return false
-      }
+      const startBlock = getSelectionStartBlock(snapshot)
+      const endBlock = getSelectionEndBlock(snapshot)
 
-      if (selectionStartBlock.node._key === selectionEndBlock.node._key) {
+      if (!startBlock || !endBlock) {
         return false
       }
 
-      const startPoint = getSelectionStartPoint(selection)
-      const startBlockEndPoint = getBlockEndPoint({
+      const startBlockStartPoint = getBlockStartPoint({
         context: snapshot.context,
-        block: selectionStartBlock,
+        block: startBlock,
       })
-      const endPoint = getSelectionEndPoint(selection)
-      const endBlockStartPoint = getBlockStartPoint({
+      const endBlockEndPoint = getBlockEndPoint({
         context: snapshot.context,
-        block: selectionEndBlock,
+        block: endBlock,
       })
 
-      const selectedValue = getSelectedValue(snapshot)
-
-      const blocksInBetween = selectedValue.filter(
-        (block) =>
-          block._key !== selectionStartBlock.node._key &&
-          block._key !== selectionEndBlock.node._key,
-      )
-
-      return {
-        startPoint,
-        startBlockEndPoint,
-        endPoint,
-        endBlockStartPoint,
-        blocksInBetween,
+      if (
+        isTextBlock(snapshot.context, startBlock.node) &&
+        isTextBlock(snapshot.context, endBlock.node) &&
+        !isEqualSelectionPoints(startPoint, startBlockStartPoint) &&
+        !isEqualSelectionPoints(endPoint, endBlockEndPoint)
+      ) {
+        return true
       }
+
+      return false
     },
-    actions: [
-      (
-        _,
-        {
-          startPoint,
-          startBlockEndPoint,
-          endPoint,
-          endBlockStartPoint,
-          blocksInBetween,
-        },
-      ) => [
-        raise({
-          type: 'delete',
-          at: {anchor: startPoint, focus: startBlockEndPoint},
-        }),
-        ...blocksInBetween.map((block) =>
-          raise({type: 'delete.block', at: [{_key: block._key}]}),
-        ),
-        raise({
-          type: 'delete',
-          at: {anchor: endBlockStartPoint, focus: endPoint},
-        }),
-      ],
-    ],
+    actions: [() => [raise({type: 'delete'}), raise({type: 'split'})]],
   }),
 
   defineBehavior({
     on: 'split',
     guard: ({snapshot}) => {
-      const selection = snapshot.context.selection
-
-      if (!selection || isSelectionCollapsed(selection)) {
-        return false
-      }
-
-      return {selection}
+      return isSelectionExpanded(snapshot)
     },
-    actions: [
-      (_, {selection}) => [
-        raise({type: 'delete', at: selection}),
-        raise({type: 'split'}),
-      ],
-    ],
+    actions: [() => [raise({type: 'delete'})]],
   }),
 
   defineBehavior({

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

@@ -204,11 +204,17 @@ const mergeTextIntoListOnBackspace = defineBehavior({
 const deletingListFromStart = defineBehavior({
   on: 'delete',
   guard: ({snapshot, event}) => {
+    const at = event.at ?? snapshot.context.selection
+
+    if (!at) {
+      return false
+    }
+
     const blocksToDelete = getSelectedBlocks({
       ...snapshot,
       context: {
         ...snapshot.context,
-        selection: event.at,
+        selection: at,
       },
     })
 
@@ -233,14 +239,14 @@ const deletingListFromStart = defineBehavior({
       ...snapshot,
       context: {
         ...snapshot.context,
-        selection: event.at,
+        selection: at,
       },
     })
     const deleteEndPoint = getSelectionEndPoint({
       ...snapshot,
       context: {
         ...snapshot.context,
-        selection: event.at,
+        selection: at,
       },
     })
 

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

@@ -140,7 +140,7 @@ export type SyntheticBehaviorEvent =
     }
   | {
       type: StrictExtract<SyntheticBehaviorEventType, 'delete'>
-      at: NonNullable<EditorSelection>
+      at?: NonNullable<EditorSelection>
       /**
        * Defaults to forward deletion.
        */

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

@@ -18,38 +18,37 @@ export function createWithEventListeners(editorActor: EditorActor) {
         return
       }
 
-      const at = options?.at ?? editor.selection
-
-      if (!at) {
-        console.error('Unexpected call to .delete(...) without `at` option')
-        return
-      }
-
-      const range = Editor.range(editor, at)
-
-      const selection = slateRangeToSelection({
-        schema: editorActor.getSnapshot().context.schema,
-        editor,
-        range,
-      })
-
-      if (!selection) {
-        console.error(
-          'Unexpected call to .delete(...) with invalid `at` option',
-        )
-        return
+      const range = options?.at ? Editor.range(editor, options.at) : undefined
+      const selection = range
+        ? slateRangeToSelection({
+            schema: editorActor.getSnapshot().context.schema,
+            editor,
+            range,
+          })
+        : undefined
+
+      if (selection) {
+        editorActor.send({
+          type: 'behavior event',
+          behaviorEvent: {
+            type: 'delete',
+            at: selection,
+            direction: options?.reverse ? 'backward' : 'forward',
+            unit: options?.unit,
+          },
+          editor,
+        })
+      } else {
+        editorActor.send({
+          type: 'behavior event',
+          behaviorEvent: {
+            type: 'delete',
+            direction: options?.reverse ? 'backward' : 'forward',
+            unit: options?.unit,
+          },
+          editor,
+        })
       }
-
-      editorActor.send({
-        type: 'behavior event',
-        behaviorEvent: {
-          type: 'delete',
-          at: selection,
-          direction: options?.reverse ? 'backward' : 'forward',
-          unit: options?.unit,
-        },
-        editor,
-      })
     }
 
     editor.deleteBackward = (unit) => {

package/src/operations/behavior.operation.delete.ts

@@ -1,14 +1,8 @@
 import {isTextBlock} from '@portabletext/schema'
-import {
-  deleteText,
-  Editor,
-  Element,
-  Range,
-  setSelection,
-  Transforms,
-} from 'slate'
+import {deleteText, Editor, Element, Range, Transforms} from 'slate'
 import {DOMEditor} from 'slate-dom'
 import {createPlaceholderBlock} from '../internal-utils/create-placeholder-block'
+import {slateRangeToSelection} from '../internal-utils/slate-utils'
 import {toSlateRange} from '../internal-utils/to-slate-range'
 import type {PortableTextSlateEditor} from '../types/editor'
 import {getBlockKeyFromSelectionPoint} from '../utils/util.selection-point'
@@ -17,48 +11,54 @@ import type {BehaviorOperationImplementation} from './behavior.operations'
 export const deleteOperationImplementation: BehaviorOperationImplementation<
   'delete'
 > = ({context, operation}) => {
-  const anchorBlockKey = getBlockKeyFromSelectionPoint(operation.at.anchor)
-  const focusBlockKey = getBlockKeyFromSelectionPoint(operation.at.focus)
-
-  const startBlockKey = operation.at.backward ? focusBlockKey : anchorBlockKey
-  const endBlockKey = operation.at.backward ? anchorBlockKey : focusBlockKey
-  const endOffset = operation.at.backward
-    ? operation.at.focus.offset
-    : operation.at.anchor.offset
-
-  if (!startBlockKey) {
-    throw new Error('Failed to get start block key')
-  }
-
-  if (!endBlockKey) {
-    throw new Error('Failed to get end block key')
-  }
-
-  const startBlockIndex = operation.editor.blockIndexMap.get(startBlockKey)
-
-  if (startBlockIndex === undefined) {
-    throw new Error('Failed to get start block index')
-  }
-
-  const startBlock = operation.editor.value.at(startBlockIndex)
-
-  if (!startBlock) {
-    throw new Error('Failed to get start block')
-  }
-
-  const endBlockIndex = operation.editor.blockIndexMap.get(endBlockKey)
-
-  if (endBlockIndex === undefined) {
-    throw new Error('Failed to get end block index')
-  }
-
-  const endBlock = operation.editor.value.at(endBlockIndex)
-
-  if (!endBlock) {
-    throw new Error('Failed to get end block')
-  }
+  const at = operation.at
+    ? toSlateRange({
+        context: {
+          schema: context.schema,
+          value: operation.editor.value,
+          selection: operation.at,
+        },
+        blockIndexMap: operation.editor.blockIndexMap,
+      })
+    : undefined
+
+  const selection = operation.editor.selection
+    ? slateRangeToSelection({
+        schema: context.schema,
+        editor: operation.editor,
+        range: operation.editor.selection,
+      })
+    : undefined
+
+  const reverse = operation.direction === 'backward'
+  const anchorPoint = operation.at?.anchor ?? selection?.anchor
+  const focusPoint = operation.at?.focus ?? selection?.focus
+  const startPoint = reverse ? focusPoint : anchorPoint
+  const endPoint = reverse ? anchorPoint : focusPoint
+  const startBlockKey = startPoint
+    ? getBlockKeyFromSelectionPoint(startPoint)
+    : undefined
+  const endBlockKey = endPoint
+    ? getBlockKeyFromSelectionPoint(endPoint)
+    : undefined
+  const startBlockIndex = startBlockKey
+    ? operation.editor.blockIndexMap.get(startBlockKey)
+    : undefined
+  const endBlockIndex = endBlockKey
+    ? operation.editor.blockIndexMap.get(endBlockKey)
+    : undefined
+  const startBlock = startBlockIndex
+    ? operation.editor.value.at(startBlockIndex)
+    : undefined
+  const endBlock = endBlockIndex
+    ? operation.editor.value.at(endBlockIndex)
+    : undefined
 
   if (operation.unit === 'block') {
+    if (startBlockIndex === undefined || endBlockIndex === undefined) {
+      throw new Error('Failed to get start or end block index')
+    }
+
     Transforms.removeNodes(operation.editor, {
       at: {
         anchor: {path: [startBlockIndex], offset: 0},
@@ -74,22 +74,13 @@ export const deleteOperationImplementation: BehaviorOperationImplementation<
     return
   }
 
-  const range = toSlateRange({
-    context: {
-      schema: context.schema,
-      value: operation.editor.value,
-      selection: operation.at,
-    },
-    blockIndexMap: operation.editor.blockIndexMap,
-  })
-
-  if (!range) {
-    throw new Error(
-      `Failed to get Slate Range for selection ${JSON.stringify(operation.at)}`,
-    )
-  }
-
   if (operation.direction === 'backward' && operation.unit === 'line') {
+    const range = at ?? operation.editor.selection ?? undefined
+
+    if (!range) {
+      throw new Error('Unable to delete line without a selection')
+    }
+
     const parentBlockEntry = Editor.above(operation.editor, {
       match: (n) => Element.isElement(n) && Editor.isBlock(operation.editor, n),
       at: range,
@@ -115,23 +106,28 @@ export const deleteOperationImplementation: BehaviorOperationImplementation<
     }
   }
 
-  const hanging = isTextBlock(context, endBlock) && endOffset === 0
-
-  deleteText(operation.editor, {
-    at: range,
-    reverse: operation.direction === 'backward',
-    unit: operation.unit,
-    hanging,
-  })
-
-  if (
-    operation.editor.selection &&
-    isTextBlock(context, startBlock) &&
-    isTextBlock(context, endBlock)
-  ) {
-    setSelection(operation.editor, {
-      anchor: operation.editor.selection.focus,
-      focus: operation.editor.selection.focus,
+  const hanging = reverse
+    ? endPoint
+      ? isTextBlock(context, endBlock)
+        ? endPoint.offset === 0
+        : true
+      : false
+    : startPoint
+      ? isTextBlock(context, startBlock)
+        ? startPoint.offset === 0
+        : true
+      : false
+
+  if (at) {
+    deleteText(operation.editor, {
+      at,
+      hanging,
+      reverse,
+    })
+  } else {
+    deleteText(operation.editor, {
+      hanging,
+      reverse,
     })
   }
 }