@portabletext/editor 1.48.13 → 1.48.14

package/src/{behavior-actions/behavior.action.annotation.add.ts → operations/behavior.operation.annotation.add.ts}

@@ -1,7 +1,7 @@
 import type {Path} from '@sanity/types'
 import {Editor, Node, Range, Text, Transforms} from 'slate'
 import {parseAnnotation} from '../internal-utils/parse-blocks'
-import type {BehaviorActionImplementation} from './behavior.actions'
+import type {BehaviorOperationImplementation} from './behavior.operations'
 
 /**
  * @public
@@ -21,14 +21,14 @@ export type AddedAnnotationPaths = {
   spanPath: Path
 }
 
-export const addAnnotationActionImplementation: BehaviorActionImplementation<
+export const addAnnotationOperationImplementation: BehaviorOperationImplementation<
   'annotation.add',
   AddedAnnotationPaths | undefined
-> = ({context, action}) => {
+> = ({context, operation}) => {
   const parsedAnnotation = parseAnnotation({
     annotation: {
-      _type: action.annotation.name,
-      ...action.annotation.value,
+      _type: operation.annotation.name,
+      ...operation.annotation.value,
     },
     context,
     options: {refreshKeys: false},
@@ -36,11 +36,11 @@ export const addAnnotationActionImplementation: BehaviorActionImplementation<
 
   if (!parsedAnnotation) {
     throw new Error(
-      `Failed to parse annotation ${JSON.stringify(action.annotation)}`,
+      `Failed to parse annotation ${JSON.stringify(operation.annotation)}`,
     )
   }
 
-  const editor = action.editor
+  const editor = operation.editor
 
   if (!editor.selection || Range.isCollapsed(editor.selection)) {
     return

package/src/{behavior-actions/behavior.action.annotation.remove.ts → operations/behavior.operation.annotation.remove.ts}

@@ -1,11 +1,11 @@
 import type {PortableTextSpan} from '@sanity/types'
 import {Editor, Node, Path, Range, Transforms} from 'slate'
-import type {BehaviorActionImplementation} from './behavior.actions'
+import type {BehaviorOperationImplementation} from './behavior.operations'
 
-export const removeAnnotationActionImplementation: BehaviorActionImplementation<
+export const removeAnnotationOperationImplementation: BehaviorOperationImplementation<
   'annotation.remove'
-> = ({action}) => {
-  const editor = action.editor
+> = ({operation}) => {
+  const editor = operation.editor
 
   if (!editor.selection) {
     return
@@ -22,7 +22,7 @@ export const removeAnnotationActionImplementation: BehaviorActionImplementation<
 
     const markDefs = block.markDefs ?? []
     const potentialAnnotations = markDefs.filter(
-      (markDef) => markDef._type === action.annotation.name,
+      (markDef) => markDef._type === operation.annotation.name,
     )
 
     const [selectedChild, selectedChildPath] = Editor.node(
@@ -132,7 +132,7 @@ export const removeAnnotationActionImplementation: BehaviorActionImplementation<
         const marks = child.marks ?? []
         const marksWithoutAnnotation = marks.filter((mark) => {
           const markDef = markDefs.find((markDef) => markDef._key === mark)
-          return markDef?._type !== action.annotation.name
+          return markDef?._type !== operation.annotation.name
         })
 
         if (marksWithoutAnnotation.length !== marks.length) {

package/src/{behavior-actions/behavior.action.block.set.ts → operations/behavior.operation.block.set.ts}

@@ -3,43 +3,43 @@ import {parseBlock} from '../internal-utils/parse-blocks'
 import {toSlateRange} from '../internal-utils/ranges'
 import {fromSlateValue, toSlateValue} from '../internal-utils/values'
 import {KEY_TO_VALUE_ELEMENT} from '../internal-utils/weakMaps'
-import type {BehaviorActionImplementation} from './behavior.actions'
+import type {BehaviorOperationImplementation} from './behavior.operations'
 
-export const blockSetBehaviorActionImplementation: BehaviorActionImplementation<
+export const blockSetOperationImplementation: BehaviorOperationImplementation<
   'block.set'
-> = ({context, action}) => {
+> = ({context, operation}) => {
   const location = toSlateRange(
     {
-      anchor: {path: action.at, offset: 0},
-      focus: {path: action.at, offset: 0},
+      anchor: {path: operation.at, offset: 0},
+      focus: {path: operation.at, offset: 0},
     },
-    action.editor,
+    operation.editor,
   )
 
   if (!location) {
     throw new Error(
-      `Unable to convert ${JSON.stringify(action.at)} into a Slate Range`,
+      `Unable to convert ${JSON.stringify(operation.at)} into a Slate Range`,
     )
   }
 
-  const blockEntry = Editor.node(action.editor, location, {depth: 1})
+  const blockEntry = Editor.node(operation.editor, location, {depth: 1})
   const block = blockEntry?.[0]
 
   if (!block) {
-    throw new Error(`Unable to find block at ${JSON.stringify(action.at)}`)
+    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`)
   }
 
   const parsedBlock = fromSlateValue(
     [block],
     context.schema.block.name,
-    KEY_TO_VALUE_ELEMENT.get(action.editor),
+    KEY_TO_VALUE_ELEMENT.get(operation.editor),
   ).at(0)
 
   if (!parsedBlock) {
-    throw new Error(`Unable to parse block at ${JSON.stringify(action.at)}`)
+    throw new Error(`Unable to parse block at ${JSON.stringify(operation.at)}`)
   }
 
-  const {_type, ...filteredProps} = action.props
+  const {_type, ...filteredProps} = operation.props
 
   const updatedBlock = parseBlock({
     context,
@@ -51,7 +51,7 @@ export const blockSetBehaviorActionImplementation: BehaviorActionImplementation<
   })
 
   if (!updatedBlock) {
-    throw new Error(`Unable to update block at ${JSON.stringify(action.at)}`)
+    throw new Error(`Unable to update block at ${JSON.stringify(operation.at)}`)
   }
 
   const slateBlock = toSlateValue([updatedBlock], {
@@ -62,5 +62,5 @@ export const blockSetBehaviorActionImplementation: BehaviorActionImplementation<
     throw new Error(`Unable to convert block to Slate value`)
   }
 
-  Transforms.setNodes(action.editor, slateBlock, {at: location})
+  Transforms.setNodes(operation.editor, slateBlock, {at: location})
 }

package/src/{behavior-actions/behavior.action.block.unset.ts → operations/behavior.operation.block.unset.ts}

@@ -4,44 +4,44 @@ import {isTextBlock, parseBlock} from '../internal-utils/parse-blocks'
 import {toSlateRange} from '../internal-utils/ranges'
 import {fromSlateValue} from '../internal-utils/values'
 import {KEY_TO_VALUE_ELEMENT} from '../internal-utils/weakMaps'
-import type {BehaviorActionImplementation} from './behavior.actions'
+import type {BehaviorOperationImplementation} from './behavior.operations'
 
-export const blockUnsetBehaviorActionImplementation: BehaviorActionImplementation<
+export const blockUnsetOperationImplementation: BehaviorOperationImplementation<
   'block.unset'
-> = ({context, action}) => {
+> = ({context, operation}) => {
   const location = toSlateRange(
     {
-      anchor: {path: action.at, offset: 0},
-      focus: {path: action.at, offset: 0},
+      anchor: {path: operation.at, offset: 0},
+      focus: {path: operation.at, offset: 0},
     },
-    action.editor,
+    operation.editor,
   )
 
   if (!location) {
     throw new Error(
-      `Unable to convert ${JSON.stringify(action.at)} into a Slate Range`,
+      `Unable to convert ${JSON.stringify(operation.at)} into a Slate Range`,
     )
   }
 
-  const blockEntry = Editor.node(action.editor, location, {depth: 1})
+  const blockEntry = Editor.node(operation.editor, location, {depth: 1})
   const block = blockEntry?.[0]
 
   if (!block) {
-    throw new Error(`Unable to find block at ${JSON.stringify(action.at)}`)
+    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`)
   }
 
   const parsedBlock = fromSlateValue(
     [block],
     context.schema.block.name,
-    KEY_TO_VALUE_ELEMENT.get(action.editor),
+    KEY_TO_VALUE_ELEMENT.get(operation.editor),
   ).at(0)
 
   if (!parsedBlock) {
-    throw new Error(`Unable to parse block at ${JSON.stringify(action.at)}`)
+    throw new Error(`Unable to parse block at ${JSON.stringify(operation.at)}`)
   }
 
   if (isTextBlock(context, parsedBlock)) {
-    const propsToRemove = action.props.filter((prop) => prop !== '_type')
+    const propsToRemove = operation.props.filter((prop) => prop !== '_type')
 
     const updatedTextBlock = parseBlock({
       context,
@@ -50,7 +50,9 @@ export const blockUnsetBehaviorActionImplementation: BehaviorActionImplementatio
     })
 
     if (!updatedTextBlock) {
-      throw new Error(`Unable to update block at ${JSON.stringify(action.at)}`)
+      throw new Error(
+        `Unable to update block at ${JSON.stringify(operation.at)}`,
+      )
     }
 
     const propsToSet: Record<string, unknown> = {}
@@ -63,7 +65,7 @@ export const blockUnsetBehaviorActionImplementation: BehaviorActionImplementatio
       }
     }
 
-    Transforms.setNodes(action.editor, propsToSet, {at: location})
+    Transforms.setNodes(operation.editor, propsToSet, {at: location})
 
     return
   }
@@ -72,19 +74,19 @@ export const blockUnsetBehaviorActionImplementation: BehaviorActionImplementatio
     context,
     block: omit(
       parsedBlock,
-      action.props.filter((prop) => prop !== '_type'),
+      operation.props.filter((prop) => prop !== '_type'),
     ),
     options: {refreshKeys: false},
   })
 
   if (!updatedBlockObject) {
-    throw new Error(`Unable to update block at ${JSON.stringify(action.at)}`)
+    throw new Error(`Unable to update block at ${JSON.stringify(operation.at)}`)
   }
 
   const {_type, _key, ...props} = updatedBlockObject
 
   Transforms.setNodes(
-    action.editor,
+    operation.editor,
     {
       _type,
       _key,

package/src/{behavior-actions/behavior.action.decorator.add.ts → operations/behavior.operation.decorator.add.ts}

@@ -5,36 +5,36 @@ import {fromSlateValue} from '../internal-utils/values'
 import {KEY_TO_VALUE_ELEMENT} from '../internal-utils/weakMaps'
 import * as selectors from '../selectors'
 import * as utils from '../utils'
-import type {BehaviorActionImplementation} from './behavior.actions'
+import type {BehaviorOperationImplementation} from './behavior.operations'
 
-export const decoratorAddActionImplementation: BehaviorActionImplementation<
+export const decoratorAddOperationImplementation: BehaviorOperationImplementation<
   'decorator.add'
-> = ({context, action}) => {
-  const editor = action.editor
-  const mark = action.decorator
+> = ({context, operation}) => {
+  const editor = operation.editor
+  const mark = operation.decorator
   const value = fromSlateValue(
     editor.children,
     context.schema.block.name,
     KEY_TO_VALUE_ELEMENT.get(editor),
   )
 
-  const manualAnchor = action.at?.anchor
+  const manualAnchor = operation.at?.anchor
     ? utils.blockOffsetToSpanSelectionPoint({
         context: {
           ...context,
           value,
         },
-        blockOffset: action.at.anchor,
+        blockOffset: operation.at.anchor,
         direction: 'backward',
       })
     : undefined
-  const manualFocus = action.at?.focus
+  const manualFocus = operation.at?.focus
     ? utils.blockOffsetToSpanSelectionPoint({
         context: {
           ...context,
           value,
         },
-        blockOffset: action.at.focus,
+        blockOffset: operation.at.focus,
         direction: 'forward',
       })
     : undefined
@@ -47,7 +47,7 @@ export const decoratorAddActionImplementation: BehaviorActionImplementation<
       : undefined
 
   const selection = manualSelection
-    ? (toSlateRange(manualSelection, action.editor) ?? editor.selection)
+    ? (toSlateRange(manualSelection, operation.editor) ?? editor.selection)
     : editor.selection
 
   if (!selection) {

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

@@ -0,0 +1,8 @@
+import {deleteBackward} from 'slate'
+import type {BehaviorOperationImplementation} from './behavior.operations'
+
+export const deleteBackwardOperationImplementation: BehaviorOperationImplementation<
+  'delete.backward'
+> = ({operation}) => {
+  deleteBackward(operation.editor, operation.unit)
+}

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

@@ -0,0 +1,24 @@
+import {Transforms} from 'slate'
+import {toSlateRange} from '../internal-utils/ranges'
+import type {BehaviorOperationImplementation} from './behavior.operations'
+
+export const deleteBlockOperationImplementation: BehaviorOperationImplementation<
+  'delete.block'
+> = ({operation}) => {
+  const range = toSlateRange(
+    {
+      anchor: {path: operation.at, offset: 0},
+      focus: {path: operation.at, offset: 0},
+    },
+    operation.editor,
+  )
+
+  if (!range) {
+    console.error('Unable to find Slate range from selection points')
+    return
+  }
+
+  Transforms.removeNodes(operation.editor, {
+    at: range,
+  })
+}

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

@@ -0,0 +1,8 @@
+import {deleteForward} from 'slate'
+import type {BehaviorOperationImplementation} from './behavior.operations'
+
+export const deleteForwardOperationImplementation: BehaviorOperationImplementation<
+  'delete.forward'
+> = ({operation}) => {
+  deleteForward(operation.editor, operation.unit)
+}

package/src/{behavior-actions/behavior.action.delete.ts → operations/behavior.operation.delete.ts}

@@ -1,25 +1,25 @@
 import {Range} from 'slate'
 import {toSlateRange} from '../internal-utils/ranges'
 import {getFocusBlock, getFocusChild} from '../internal-utils/slate-utils'
-import type {BehaviorActionImplementation} from './behavior.actions'
+import type {BehaviorOperationImplementation} from './behavior.operations'
 
-export const deleteActionImplementation: BehaviorActionImplementation<
+export const deleteOperationImplementation: BehaviorOperationImplementation<
   'delete'
-> = ({context, action}) => {
-  const range = toSlateRange(action.at, action.editor)
+> = ({context, operation}) => {
+  const range = toSlateRange(operation.at, operation.editor)
 
   if (!range) {
     throw new Error(
-      `Failed to get Slate Range for selection ${JSON.stringify(action.at)}`,
+      `Failed to get Slate Range for selection ${JSON.stringify(operation.at)}`,
     )
   }
 
   if (Range.isCollapsed(range)) {
     const [focusBlock] = getFocusBlock({
-      editor: {...action.editor, selection: range},
+      editor: {...operation.editor, selection: range},
     })
     const [focusChild] = getFocusChild({
-      editor: {...action.editor, selection: range},
+      editor: {...operation.editor, selection: range},
     })
 
     if (
@@ -32,5 +32,5 @@ export const deleteActionImplementation: BehaviorActionImplementation<
     }
   }
 
-  action.editor.delete({at: range})
+  operation.editor.delete({at: range})
 }

package/src/{behavior-actions/behavior.action.insert-inline-object.ts → operations/behavior.operation.insert-inline-object.ts}

@@ -1,35 +1,35 @@
 import {Editor, Transforms, type Element} from 'slate'
 import {parseInlineObject} from '../internal-utils/parse-blocks'
 import {toSlateValue} from '../internal-utils/values'
-import type {BehaviorActionImplementation} from './behavior.actions'
+import type {BehaviorOperationImplementation} from './behavior.operations'
 
-export const insertInlineObjectActionImplementation: BehaviorActionImplementation<
+export const insertInlineObjectOperationImplementation: BehaviorOperationImplementation<
   'insert.inline object'
-> = ({context, action}) => {
+> = ({context, operation}) => {
   const parsedInlineObject = parseInlineObject({
     context,
     inlineObject: {
-      _type: action.inlineObject.name,
-      ...(action.inlineObject.value ?? {}),
+      _type: operation.inlineObject.name,
+      ...(operation.inlineObject.value ?? {}),
     },
     options: {refreshKeys: false},
   })
 
   if (!parsedInlineObject) {
     throw new Error(
-      `Failed to parse inline object ${JSON.stringify(action.inlineObject)}`,
+      `Failed to parse inline object ${JSON.stringify(operation.inlineObject)}`,
     )
   }
 
-  if (!action.editor.selection) {
+  if (!operation.editor.selection) {
     console.error('Unable to insert inline object without selection')
     return
   }
 
   const [focusTextBlock] = Array.from(
-    Editor.nodes(action.editor, {
-      at: action.editor.selection.focus.path,
-      match: (node) => action.editor.isTextBlock(node),
+    Editor.nodes(operation.editor, {
+      at: operation.editor.selection.focus.path,
+      match: (node) => operation.editor.isTextBlock(node),
     }),
   ).at(0) ?? [undefined, undefined]
 
@@ -55,5 +55,5 @@ export const insertInlineObjectActionImplementation: BehaviorActionImplementatio
     return
   }
 
-  Transforms.insertNodes(action.editor, child)
+  Transforms.insertNodes(operation.editor, child)
 }

package/src/{behavior-actions/behavior.action.insert-span.ts → operations/behavior.operation.insert-span.ts}

@@ -1,29 +1,29 @@
 import {Editor, Transforms} from 'slate'
-import type {BehaviorActionImplementation} from './behavior.actions'
+import type {BehaviorOperationImplementation} from './behavior.operations'
 
-export const insertSpanActionImplementation: BehaviorActionImplementation<
+export const insertSpanOperationImplementation: BehaviorOperationImplementation<
   'insert.span'
-> = ({context, action}) => {
-  if (!action.editor.selection) {
-    console.error('Unable to perform action without selection', action)
+> = ({context, operation}) => {
+  if (!operation.editor.selection) {
+    console.error('Unable to perform action without selection', operation)
     return
   }
 
   const [focusBlock, focusBlockPath] = Array.from(
-    Editor.nodes(action.editor, {
-      at: action.editor.selection.focus.path,
-      match: (node) => action.editor.isTextBlock(node),
+    Editor.nodes(operation.editor, {
+      at: operation.editor.selection.focus.path,
+      match: (node) => operation.editor.isTextBlock(node),
     }),
   )[0] ?? [undefined, undefined]
 
   if (!focusBlock || !focusBlockPath) {
-    console.error('Unable to perform action without focus block', action)
+    console.error('Unable to perform action without focus block', operation)
     return
   }
 
   const markDefs = focusBlock.markDefs ?? []
-  const annotations = action.annotations
-    ? action.annotations.map((annotation) => ({
+  const annotations = operation.annotations
+    ? operation.annotations.map((annotation) => ({
         _type: annotation.name,
         _key: context.keyGenerator(),
         ...annotation.value,
@@ -31,18 +31,18 @@ export const insertSpanActionImplementation: BehaviorActionImplementation<
     : undefined
 
   if (annotations && annotations.length > 0) {
-    Transforms.setNodes(action.editor, {
+    Transforms.setNodes(operation.editor, {
       markDefs: [...markDefs, ...annotations],
     })
   }
 
-  Transforms.insertNodes(action.editor, {
+  Transforms.insertNodes(operation.editor, {
     _type: 'span',
     _key: context.keyGenerator(),
-    text: action.text,
+    text: operation.text,
     marks: [
       ...(annotations?.map((annotation) => annotation._key) ?? []),
-      ...(action.decorators ?? []),
+      ...(operation.decorators ?? []),
     ],
   })
 }

package/src/{behavior-actions/behavior.action.insert.block.ts → operations/behavior.operation.insert.block.ts}

@@ -11,19 +11,19 @@ import {
 } from '../internal-utils/slate-utils'
 import {isEqualToEmptyEditor, toSlateValue} from '../internal-utils/values'
 import type {PortableTextSlateEditor} from '../types/editor'
-import type {BehaviorActionImplementation} from './behavior.actions'
+import type {BehaviorOperationImplementation} from './behavior.operations'
 
-export const insertBlockActionImplementation: BehaviorActionImplementation<
+export const insertBlockOperationImplementation: BehaviorOperationImplementation<
   'insert.block'
-> = ({context, action}) => {
+> = ({context, operation}) => {
   const parsedBlock = parseBlock({
-    block: action.block,
+    block: operation.block,
     context,
     options: {refreshKeys: false},
   })
 
   if (!parsedBlock) {
-    throw new Error(`Failed to parse block ${JSON.stringify(action.block)}`)
+    throw new Error(`Failed to parse block ${JSON.stringify(operation.block)}`)
   }
 
   const fragment = toSlateValue([parsedBlock], {schemaTypes: context.schema})[0]
@@ -36,9 +36,9 @@ export const insertBlockActionImplementation: BehaviorActionImplementation<
 
   insertBlock({
     block: fragment,
-    placement: action.placement,
-    select: action.select ?? 'start',
-    editor: action.editor,
+    placement: operation.placement,
+    select: operation.select ?? 'start',
+    editor: operation.editor,
     schema: context.schema,
   })
 }

package/src/operations/behavior.operation.insert.text.ts

@@ -0,0 +1,17 @@
+import {Transforms} from 'slate'
+import type {BehaviorOperationImplementation} from './behavior.operations'
+
+export const insertTextOperationImplementation: BehaviorOperationImplementation<
+  'insert.text'
+> = ({operation}) => {
+  if (operation.editor.marks) {
+    Transforms.insertNodes(operation.editor, {
+      text: operation.text,
+      ...operation.editor.marks,
+    })
+  } else {
+    Transforms.insertText(operation.editor, operation.text)
+  }
+
+  operation.editor.marks = null
+}

package/src/operations/behavior.operation.move.backward.ts

@@ -0,0 +1,12 @@
+import {Transforms} from 'slate'
+import type {BehaviorOperationImplementation} from './behavior.operations'
+
+export const moveBackwardOperationImplementation: BehaviorOperationImplementation<
+  'move.backward'
+> = ({operation}) => {
+  Transforms.move(operation.editor, {
+    unit: 'character',
+    distance: operation.distance,
+    reverse: true,
+  })
+}

package/src/operations/behavior.operation.move.block.ts

@@ -0,0 +1,16 @@
+import {Transforms} from 'slate'
+import {toSlatePath} from '../internal-utils/paths'
+import type {BehaviorOperationImplementation} from './behavior.operations'
+
+export const moveBlockOperationImplementation: BehaviorOperationImplementation<
+  'move.block'
+> = ({operation}) => {
+  const at = [toSlatePath(operation.at, operation.editor)[0]]
+  const to = [toSlatePath(operation.to, operation.editor)[0]]
+
+  Transforms.moveNodes(operation.editor, {
+    at,
+    to,
+    mode: 'highest',
+  })
+}

package/src/operations/behavior.operation.move.forward.ts

@@ -0,0 +1,11 @@
+import {Transforms} from 'slate'
+import type {BehaviorOperationImplementation} from './behavior.operations'
+
+export const moveForwardOperationImplementation: BehaviorOperationImplementation<
+  'move.forward'
+> = ({operation}) => {
+  Transforms.move(operation.editor, {
+    unit: 'character',
+    distance: operation.distance,
+  })
+}

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

@@ -0,0 +1,15 @@
+import {Transforms} from 'slate'
+import {toSlateRange} from '../internal-utils/ranges'
+import type {BehaviorOperationImplementation} from './behavior.operations'
+
+export const selectOperationImplementation: BehaviorOperationImplementation<
+  'select'
+> = ({operation}) => {
+  const newSelection = toSlateRange(operation.at, operation.editor)
+
+  if (newSelection) {
+    Transforms.select(operation.editor, newSelection)
+  } else {
+    Transforms.deselect(operation.editor)
+  }
+}