@portabletext/editor 2.7.2 → 2.8.1

package/src/selectors/selector.get-selected-value.ts

@@ -35,13 +35,34 @@ export const getSelectedValue: EditorSelector<Array<PortableTextBlock>> = (
     return []
   }
 
-  const slicedValue = snapshot.context.value.slice(
-    startBlockIndex,
-    endBlockIndex + 1,
+  const startBlock = snapshot.context.value.at(startBlockIndex)
+  const slicedStartBlock = startBlock
+    ? sliceBlocks({
+        context: snapshot.context,
+        blocks: [startBlock],
+      }).at(0)
+    : undefined
+
+  if (startBlockIndex === endBlockIndex) {
+    return slicedStartBlock ? [slicedStartBlock] : []
+  }
+
+  const endBlock = snapshot.context.value.at(endBlockIndex)
+  const slicedEndBlock = endBlock
+    ? sliceBlocks({
+        context: snapshot.context,
+        blocks: [endBlock],
+      }).at(0)
+    : undefined
+
+  const middleBlocks = snapshot.context.value.slice(
+    startBlockIndex + 1,
+    endBlockIndex,
   )
 
-  return sliceBlocks({
-    context: snapshot.context,
-    blocks: slicedValue,
-  })
+  return [
+    ...(slicedStartBlock ? [slicedStartBlock] : []),
+    ...middleBlocks,
+    ...(slicedEndBlock ? [slicedEndBlock] : []),
+  ]
 }

package/src/selectors/selector.get-trimmed-selection.test.ts

@@ -33,7 +33,6 @@ function snapshot(
           },
           block,
           options: {
-            refreshKeys: false,
             validateFields: false,
           },
         })

package/src/selectors/selector.is-active-annotation.test.ts

@@ -0,0 +1,320 @@
+import {compileSchema, defineSchema} from '@portabletext/schema'
+import {createTestKeyGenerator} from '@portabletext/test'
+import {describe, expect, test} from 'vitest'
+import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
+import {isActiveAnnotation} from './selector.is-active-annotation'
+
+describe(isActiveAnnotation.name, () => {
+  const keyGenerator = createTestKeyGenerator()
+  const annotationKey = keyGenerator()
+  const blockKey = keyGenerator()
+  const fooKey = keyGenerator()
+  const barKey = keyGenerator()
+  const bazKey = keyGenerator()
+  const value = [
+    {
+      _type: 'block',
+      _key: blockKey,
+      children: [
+        {
+          _type: 'span',
+          _key: fooKey,
+          text: 'foo ',
+          marks: [],
+        },
+        {
+          _type: 'span',
+          _key: barKey,
+          text: 'bar',
+          marks: [annotationKey],
+        },
+        {
+          _type: 'span',
+          _key: bazKey,
+          text: ' baz',
+          marks: [],
+        },
+      ],
+      markDefs: [
+        {_key: annotationKey, _type: 'link', href: 'https://example.com'},
+      ],
+    },
+  ]
+  const schema = compileSchema(
+    defineSchema({
+      annotations: [{name: 'link', fields: [{name: 'href', type: 'string'}]}],
+    }),
+  )
+
+  describe('collapsed selection', () => {
+    test('selection before the annotation', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: fooKey}],
+              offset: 4,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: fooKey}],
+              offset: 4,
+            },
+          },
+        },
+      })
+
+      expect(isActiveAnnotation('link')(snapshot)).toBe(false)
+    })
+
+    test('selection at the start of the annotation', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 0,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 0,
+            },
+          },
+        },
+      })
+
+      expect(isActiveAnnotation('link')(snapshot)).toBe(false)
+    })
+
+    test('selection after the annotation', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: bazKey}],
+              offset: 0,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: bazKey}],
+              offset: 0,
+            },
+          },
+        },
+      })
+
+      expect(isActiveAnnotation('link')(snapshot)).toBe(false)
+    })
+
+    test('selection at the end of the annotation', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 3,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 3,
+            },
+          },
+        },
+      })
+
+      expect(isActiveAnnotation('link')(snapshot)).toBe(false)
+    })
+
+    test('selection in the annotation', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 2,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 2,
+            },
+          },
+        },
+      })
+
+      expect(isActiveAnnotation('link')(snapshot)).toBe(true)
+    })
+  })
+
+  describe('expanded selection', () => {
+    test('selection on the annotation', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 0,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 3,
+            },
+          },
+        },
+      })
+
+      expect(isActiveAnnotation('link')(snapshot)).toBe(true)
+    })
+
+    test('selection in the annotation', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 1,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 2,
+            },
+          },
+        },
+      })
+
+      expect(isActiveAnnotation('link')(snapshot)).toBe(true)
+    })
+
+    describe('selection including the annotation', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: fooKey}],
+              offset: 2,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: bazKey}],
+              offset: 2,
+            },
+          },
+        },
+      })
+
+      test('mode: full', () => {
+        expect(isActiveAnnotation('link')(snapshot)).toBe(false)
+      })
+
+      test('mode: partial', () => {
+        expect(isActiveAnnotation('link', {mode: 'partial'})(snapshot)).toBe(
+          true,
+        )
+      })
+    })
+
+    describe('selection before the annotation', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: fooKey}],
+              offset: 0,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: fooKey}],
+              offset: 4,
+            },
+          },
+        },
+      })
+
+      test('mode: full', () => {
+        expect(isActiveAnnotation('link')(snapshot)).toBe(false)
+      })
+
+      test('mode: partial', () => {
+        expect(isActiveAnnotation('link', {mode: 'partial'})(snapshot)).toBe(
+          false,
+        )
+      })
+    })
+
+    test('selection overlapping from the start', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: fooKey}],
+              offset: 0,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 2,
+            },
+          },
+        },
+      })
+
+      expect(isActiveAnnotation('link')(snapshot)).toBe(false)
+    })
+
+    test('selection after the annotation', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: bazKey}],
+              offset: 0,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: bazKey}],
+              offset: 4,
+            },
+          },
+        },
+      })
+
+      expect(isActiveAnnotation('link')(snapshot)).toBe(false)
+    })
+
+    test('selection overlapping from the end', () => {
+      const snapshot = createTestSnapshot({
+        context: {
+          schema,
+          value,
+          selection: {
+            anchor: {
+              path: [{_key: blockKey}, 'children', {_key: barKey}],
+              offset: 2,
+            },
+            focus: {
+              path: [{_key: blockKey}, 'children', {_key: bazKey}],
+              offset: 4,
+            },
+          },
+        },
+      })
+
+      expect(isActiveAnnotation('link')(snapshot)).toBe(false)
+    })
+  })
+})

package/src/selectors/selector.is-active-annotation.ts

@@ -2,14 +2,38 @@ import {isTextBlock} from '@portabletext/schema'
 import type {EditorSelector} from '../editor/editor-selector'
 import {getActiveAnnotationsMarks} from './selector.get-active-annotation-marks'
 import {getSelectedBlocks} from './selector.get-selected-blocks'
+import {getSelectedValue} from './selector.get-selected-value'
 
 /**
+ * Check whether an annotation is active in the given `snapshot`.
+ *
  * @public
  */
 export function isActiveAnnotation(
   annotation: string,
+  options?: {
+    /**
+     * Choose whether the annotation has to take up the entire selection in the
+     * `snapshot` or if the annotation can be partially selected.
+     *
+     * Defaults to 'full'
+     */
+    mode?: 'partial' | 'full'
+  },
 ): EditorSelector<boolean> {
   return (snapshot) => {
+    const mode = options?.mode ?? 'full'
+
+    if (mode === 'partial') {
+      const selectedValue = getSelectedValue(snapshot)
+
+      const selectionMarkDefs = selectedValue.flatMap((block) =>
+        isTextBlock(snapshot.context, block) ? (block.markDefs ?? []) : [],
+      )
+
+      return selectionMarkDefs.some((markDef) => markDef._type === annotation)
+    }
+
     const selectedBlocks = getSelectedBlocks(snapshot)
     const selectionMarkDefs = selectedBlocks.flatMap((block) =>
       isTextBlock(snapshot.context, block.node)

package/src/utils/util.merge-text-blocks.ts

@@ -18,7 +18,7 @@ export function mergeTextBlocks({
   const parsedIncomingBlock = parseBlock({
     context,
     block: incomingBlock,
-    options: {refreshKeys: false, validateFields: false},
+    options: {validateFields: false},
   })
 
   if (!parsedIncomingBlock || !isTextBlock(context, parsedIncomingBlock)) {

package/src/utils/util.slice-blocks.ts

@@ -1,6 +1,8 @@
 import {isSpan, isTextBlock} from '@portabletext/schema'
 import type {PortableTextBlock} from '@sanity/types'
 import type {EditorContext} from '../editor/editor-snapshot'
+import {defaultKeyGenerator} from '../editor/key-generator'
+import {parseBlock} from '../internal-utils/parse-blocks'
 import {
   getBlockKeyFromSelectionPoint,
   getChildKeyFromSelectionPoint,
@@ -162,13 +164,44 @@ export function sliceBlocks({
     }
 
     if (startBlock) {
-      middleBlocks.push(block)
+      middleBlocks.push(
+        parseBlock({
+          context: {
+            ...context,
+            keyGenerator: defaultKeyGenerator,
+          },
+          block,
+          options: {validateFields: false},
+        }) ?? block,
+      )
     }
   }
 
+  const parsedStartBlock = startBlock
+    ? parseBlock({
+        context: {
+          ...context,
+          keyGenerator: defaultKeyGenerator,
+        },
+        block: startBlock,
+        options: {validateFields: false},
+      })
+    : undefined
+
+  const parsedEndBlock = endBlock
+    ? parseBlock({
+        context: {
+          ...context,
+          keyGenerator: defaultKeyGenerator,
+        },
+        block: endBlock,
+        options: {validateFields: false},
+      })
+    : undefined
+
   return [
-    ...(startBlock ? [startBlock] : []),
+    ...(parsedStartBlock ? [parsedStartBlock] : []),
     ...middleBlocks,
-    ...(endBlock ? [endBlock] : []),
+    ...(parsedEndBlock ? [parsedEndBlock] : []),
   ]
 }