@portabletext/editor 2.13.6 → 2.13.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "2.13.6",
+  "version": "2.13.7",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -86,9 +86,9 @@
     "slate-react": "0.117.4",
     "xstate": "^5.22.1",
     "@portabletext/block-tools": "^3.5.10",
+    "@portabletext/keyboard-shortcuts": "^1.1.1",
     "@portabletext/patches": "^1.1.8",
-    "@portabletext/schema": "^1.2.0",
-    "@portabletext/keyboard-shortcuts": "^1.1.1"
+    "@portabletext/schema": "^1.2.0"
   },
   "devDependencies": {
     "@sanity/diff-match-patch": "^3.2.0",

package/src/editor/plugins/createWithPortableTextMarkModel.ts

@@ -4,7 +4,7 @@
  *
  */
 
-import {isSpan, isTextBlock} from '@portabletext/schema'
+import {isTextBlock} from '@portabletext/schema'
 import type {PortableTextObject, PortableTextSpan} from '@sanity/types'
 import {isEqual, uniq} from 'lodash'
 import {Editor, Element, Node, Path, Range, Text, Transforms} from 'slate'
@@ -12,7 +12,6 @@ import {debugWithName} from '../../internal-utils/debug'
 import {getNextSpan, getPreviousSpan} from '../../internal-utils/sibling-utils'
 import type {BehaviorOperationImplementation} from '../../operations/behavior.operations'
 import {getActiveDecorators} from '../../selectors/selector.get-active-decorators'
-import {getMarkState} from '../../selectors/selector.get-mark-state'
 import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
 import {getEditorSnapshot} from '../editor-selector'
@@ -325,122 +324,6 @@ export function createWithPortableTextMarkModel(
         }
       }
 
-      if (op.type === 'insert_node') {
-        const {selection} = editor
-
-        if (selection) {
-          const [_block, blockPath] = Editor.node(editor, selection, {depth: 1})
-          const previousSpan = getPreviousSpan({
-            editor,
-            blockPath,
-            spanPath: op.path,
-          })
-          const previousSpanAnnotations = previousSpan
-            ? previousSpan.marks?.filter((mark) => !decorators.includes(mark))
-            : []
-
-          const nextSpan = getNextSpan({
-            editor,
-            blockPath,
-            spanPath: [op.path[0], op.path[1] - 1],
-          })
-          const nextSpanAnnotations = nextSpan
-            ? nextSpan.marks?.filter((mark) => !decorators.includes(mark))
-            : []
-
-          const annotationsEnding =
-            previousSpanAnnotations?.filter(
-              (annotation) => !nextSpanAnnotations?.includes(annotation),
-            ) ?? []
-          const atTheEndOfAnnotation = annotationsEnding.length > 0
-
-          if (
-            atTheEndOfAnnotation &&
-            isSpan(editorActor.getSnapshot().context, op.node) &&
-            op.node.marks?.some((mark) => annotationsEnding.includes(mark))
-          ) {
-            Transforms.insertNodes(editor, {
-              ...op.node,
-              _key: editorActor.getSnapshot().context.keyGenerator(),
-              marks:
-                op.node.marks?.filter(
-                  (mark) => !annotationsEnding.includes(mark),
-                ) ?? [],
-            })
-            return
-          }
-
-          const annotationsStarting =
-            nextSpanAnnotations?.filter(
-              (annotation) => !previousSpanAnnotations?.includes(annotation),
-            ) ?? []
-          const atTheStartOfAnnotation = annotationsStarting.length > 0
-
-          if (
-            atTheStartOfAnnotation &&
-            isSpan(editorActor.getSnapshot().context, op.node) &&
-            op.node.marks?.some((mark) => annotationsStarting.includes(mark))
-          ) {
-            Transforms.insertNodes(editor, {
-              ...op.node,
-              _key: editorActor.getSnapshot().context.keyGenerator(),
-              marks:
-                op.node.marks?.filter(
-                  (mark) => !annotationsStarting.includes(mark),
-                ) ?? [],
-            })
-            return
-          }
-
-          const nextSpanDecorators =
-            nextSpan?.marks?.filter((mark) => decorators.includes(mark)) ?? []
-          const decoratorStarting = nextSpanDecorators.length > 0
-
-          if (
-            decoratorStarting &&
-            atTheEndOfAnnotation &&
-            !atTheStartOfAnnotation &&
-            isSpan(editorActor.getSnapshot().context, op.node) &&
-            op.node.marks?.length === 0
-          ) {
-            Transforms.insertNodes(editor, {
-              ...op.node,
-              _key: editorActor.getSnapshot().context.keyGenerator(),
-              marks: nextSpanDecorators,
-            })
-            return
-          }
-        }
-      }
-
-      if (op.type === 'insert_text') {
-        const snapshot = getEditorSnapshot({
-          editorActorSnapshot: editorActor.getSnapshot(),
-          slateEditorInstance: editor,
-        })
-
-        const markState = getMarkState(snapshot)
-
-        if (!markState) {
-          apply(op)
-          return
-        }
-
-        if (markState.state === 'unchanged') {
-          apply(op)
-          return
-        }
-
-        Transforms.insertNodes(editor, {
-          _type: 'span',
-          _key: editorActor.getSnapshot().context.keyGenerator(),
-          text: op.text,
-          marks: markState.marks,
-        })
-
-        return
-      }
-
       if (op.type === 'remove_text') {
         const {selection} = editor
 

package/src/selectors/selector.get-mark-state.test.ts

@@ -73,4 +73,67 @@ describe(getMarkState.name, () => {
       previousMarks: [linkKey, 'strong'],
     })
   })
+
+  test('Scenario: Caret after annotation inside decorator', () => {
+    const keyGenerator = createTestKeyGenerator()
+    const blockKey = keyGenerator()
+    const fooSpanKey = keyGenerator()
+    const barSpanKey = keyGenerator()
+    const bazSpanKey = keyGenerator()
+    const linkKey = keyGenerator()
+    const snapshot = createTestSnapshot({
+      context: {
+        keyGenerator,
+        value: [
+          {
+            _type: 'block',
+            _key: blockKey,
+            children: [
+              {
+                _type: 'span',
+                _key: fooSpanKey,
+                text: 'foo ',
+                marks: ['strong'],
+              },
+              {
+                _type: 'span',
+                _key: barSpanKey,
+                text: 'bar',
+                marks: [linkKey, 'strong'],
+              },
+              {
+                _type: 'span',
+                _key: bazSpanKey,
+                text: ' baz',
+                marks: ['strong'],
+              },
+            ],
+          },
+        ],
+        selection: {
+          anchor: {
+            path: [{_key: blockKey}, 'children', {_key: bazSpanKey}],
+            offset: 0,
+          },
+          focus: {
+            path: [{_key: blockKey}, 'children', {_key: bazSpanKey}],
+            offset: 0,
+          },
+          backward: false,
+        },
+        schema: compileSchema(
+          defineSchema({
+            annotations: [{name: 'link'}],
+            decorators: [{name: 'strong'}],
+          }),
+        ),
+      },
+    })
+
+    expect(getMarkState(snapshot)).toEqual({
+      state: 'changed',
+      marks: ['strong'],
+      previousMarks: [linkKey, 'strong'],
+    })
+  })
 })

package/src/selectors/selector.get-mark-state.ts

@@ -236,8 +236,8 @@ export const getMarkState: EditorSelector<MarkState | undefined> = (
     if (previousSpanHasAnnotations) {
       return {
         state: 'changed',
-        previousMarks: previousSpan.node.marks ?? [],
-        marks: [],
+        marks,
+        previousMarks: previousSpan?.node.marks ?? [],
       }
     } else {
       return {