@portabletext/editor 1.48.13 → 1.48.15

package/src/editor/plugins/createWithPatches.ts

@@ -27,7 +27,7 @@ import {
 } from '../../internal-utils/withoutPatching'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
-import {getCurrentActionId} from '../with-applying-behavior-actions'
+import {getCurrentOperationId} from '../with-applying-behavior-operations'
 import {withoutSaving} from './createWithUndoRedo'
 
 const debug = debugWithName('plugin:withPatches')
@@ -108,15 +108,23 @@ export function createWithPatches({
       const patches = bufferedPatches
       bufferedPatches = []
       let changed = false
+
       withRemoteChanges(editor, () => {
         Editor.withoutNormalizing(editor, () => {
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
-              patches.forEach((patch) => {
+              for (const patch of patches) {
                 if (debug.enabled)
                   debug(`Handling remote patch ${JSON.stringify(patch)}`)
-                changed = applyPatch(editor, patch)
-              })
+
+                try {
+                  changed = applyPatch(editor, patch)
+                } catch (error) {
+                  console.error(
+                    `Applying patch ${JSON.stringify(patch)} failed due to: ${error.message}`,
+                  )
+                }
+              }
             })
           })
         })
@@ -293,7 +301,7 @@ export function createWithPatches({
           editorActor.send({
             type: 'internal.patch',
             patch: {...patch, origin: 'local'},
-            actionId: getCurrentActionId(editor),
+            operationId: getCurrentOperationId(editor),
             value: fromSlateValue(
               editor.children,
               editorActor.getSnapshot().context.schema.block.name,

package/src/editor/plugins/createWithPortableTextMarkModel.ts

@@ -8,11 +8,11 @@ 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 type {BehaviorActionImplementation} from '../../behavior-actions/behavior.actions'
 import {debugWithName} from '../../internal-utils/debug'
 import {getNextSpan, getPreviousSpan} from '../../internal-utils/sibling-utils'
 import {isChangingRemotely} from '../../internal-utils/withChanges'
 import {isRedoing, isUndoing} from '../../internal-utils/withUndoRedo'
+import type {BehaviorOperationImplementation} from '../../operations/behavior.operations'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
 
@@ -660,11 +660,11 @@ export function createWithPortableTextMarkModel(
   }
 }
 
-export const removeDecoratorActionImplementation: BehaviorActionImplementation<
+export const removeDecoratorOperationImplementation: BehaviorOperationImplementation<
   'decorator.remove'
-> = ({action}) => {
-  const editor = action.editor
-  const mark = action.decorator
+> = ({operation}) => {
+  const editor = operation.editor
+  const mark = operation.decorator
   const {selection} = editor
 
   if (selection) {

package/src/editor/plugins/createWithUndoRedo.ts

@@ -20,7 +20,6 @@ import {
   type Descendant,
   type SelectionOperation,
 } from 'slate'
-import type {BehaviorActionImplementation} from '../../behavior-actions/behavior.actions'
 import {debugWithName} from '../../internal-utils/debug'
 import {fromSlateValue} from '../../internal-utils/values'
 import {isChangingRemotely} from '../../internal-utils/withChanges'
@@ -32,9 +31,10 @@ import {
   withRedoing,
   withUndoing,
 } from '../../internal-utils/withUndoRedo'
+import type {BehaviorOperationImplementation} from '../../operations/behavior.operations'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
-import {getCurrentUndoStepId} from '../with-applying-behavior-actions'
+import {getCurrentUndoStepId} from '../with-undo-step'
 
 const debug = debugWithName('plugin:withUndoRedo')
 const debugVerbose = debug.enabled && false
@@ -203,10 +203,10 @@ export function createWithUndoRedo(
   }
 }
 
-export const historyUndoActionImplementation: BehaviorActionImplementation<
+export const historyUndoOperationImplementation: BehaviorOperationImplementation<
   'history.undo'
-> = ({action}) => {
-  const editor = action.editor
+> = ({operation}) => {
+  const editor = operation.editor
   const {undos} = editor.history
   const remotePatches = getRemotePatches(editor)
 
@@ -261,10 +261,10 @@ export const historyUndoActionImplementation: BehaviorActionImplementation<
   }
 }
 
-export const historyRedoActionImplementation: BehaviorActionImplementation<
+export const historyRedoOperationImplementation: BehaviorOperationImplementation<
   'history.redo'
-> = ({action}) => {
-  const editor = action.editor
+> = ({operation}) => {
+  const editor = operation.editor
   const {redos} = editor.history
   const remotePatches = getRemotePatches(editor)
 

package/src/editor/with-applying-behavior-operations.ts

@@ -0,0 +1,18 @@
+import {Editor} from 'slate'
+import {defaultKeyGenerator} from './key-generator'
+
+const CURRENT_OPERATION_ID: WeakMap<Editor, string | undefined> = new WeakMap()
+
+export function withApplyingBehaviorOperations(editor: Editor, fn: () => void) {
+  CURRENT_OPERATION_ID.set(editor, defaultKeyGenerator())
+  Editor.withoutNormalizing(editor, fn)
+  CURRENT_OPERATION_ID.set(editor, undefined)
+}
+
+export function getCurrentOperationId(editor: Editor) {
+  return CURRENT_OPERATION_ID.get(editor)
+}
+
+export function isApplyingBehaviorOperations(editor: Editor) {
+  return getCurrentOperationId(editor) !== undefined
+}

package/src/editor/{with-applying-behavior-actions.ts → with-undo-step.ts}

@@ -1,24 +1,6 @@
-import {Editor} from 'slate'
+import type {Editor} from 'slate'
 import {defaultKeyGenerator} from './key-generator'
 
-const CURRENT_ACTION_ID: WeakMap<Editor, string | undefined> = new WeakMap()
-
-export function withApplyingBehaviorActions(editor: Editor, fn: () => void) {
-  CURRENT_ACTION_ID.set(editor, defaultKeyGenerator())
-  Editor.withoutNormalizing(editor, fn)
-  CURRENT_ACTION_ID.set(editor, undefined)
-}
-
-export function getCurrentActionId(editor: Editor) {
-  return CURRENT_ACTION_ID.get(editor)
-}
-
-export function isApplyingBehaviorActions(editor: Editor) {
-  return getCurrentActionId(editor) !== undefined
-}
-
-////////
-
 const CURRENT_UNDO_STEP: WeakMap<Editor, {undoStepId: string} | undefined> =
   new WeakMap()
 

package/src/index.ts

@@ -4,7 +4,7 @@ export type {
   PortableTextChild,
   PortableTextSpan,
 } from '@sanity/types'
-export type {AddedAnnotationPaths} from './behavior-actions/behavior.action.annotation.add'
+export type {AddedAnnotationPaths} from './operations/behavior.operation.annotation.add'
 export {EditorEventListener} from './editor-event-listener'
 export type {Editor, EditorConfig, EditorEvent} from './editor/create-editor'
 export {

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)
 }