@portabletext/editor 2.8.0 → 2.8.2

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/types/editor.ts

@@ -37,6 +37,24 @@ export interface EditableAPIDeleteOptions {
   mode?: 'blocks' | 'children' | 'selected'
 }
 
+/**
+ * @public
+ */
+export type AddedAnnotationPaths = {
+  /**
+   * @deprecated An annotation may be applied to multiple blocks, resulting
+   * in multiple `markDef`'s being created. Use `markDefPaths` instead.
+   */
+  markDefPath: Path
+  markDefPaths: Array<Path>
+  /**
+   * @deprecated Does not return anything meaningful since an annotation
+   * can span multiple blocks and spans. If references the span closest
+   * to the focus point of the selection.
+   */
+  spanPath: Path
+}
+
 /** @beta */
 export interface EditableAPI {
   activeAnnotations: () => PortableTextObject[]
@@ -44,9 +62,7 @@ export interface EditableAPI {
   addAnnotation: <TSchemaType extends {name: string}>(
     type: TSchemaType,
     value?: {[prop: string]: unknown},
-  ) =>
-    | {markDefPath: Path; markDefPaths: Array<Path>; spanPath: Path}
-    | undefined
+  ) => AddedAnnotationPaths | undefined
   blur: () => void
   delete: (
     selection: EditorSelection,

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

@@ -171,7 +171,7 @@ export function sliceBlocks({
             keyGenerator: defaultKeyGenerator,
           },
           block,
-          options: {refreshKeys: false, validateFields: false},
+          options: {validateFields: false},
         }) ?? block,
       )
     }
@@ -184,7 +184,7 @@ export function sliceBlocks({
           keyGenerator: defaultKeyGenerator,
         },
         block: startBlock,
-        options: {refreshKeys: false, validateFields: false},
+        options: {validateFields: false},
       })
     : undefined
 
@@ -195,7 +195,7 @@ export function sliceBlocks({
           keyGenerator: defaultKeyGenerator,
         },
         block: endBlock,
-        options: {refreshKeys: false, validateFields: false},
+        options: {validateFields: false},
       })
     : undefined
 

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

@@ -1,499 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import type {PortableTextBlock, PortableTextTextBlock} from '@sanity/types'
-import {describe, expect, test} from 'vitest'
-import {sliceBlocks} from './util.slice-blocks'
-
-const b1: PortableTextTextBlock = {
-  _type: 'block',
-  _key: 'b1',
-  children: [
-    {
-      _type: 'span',
-      _key: 'b1c1',
-      text: 'foo',
-      marks: [],
-    },
-    {
-      _type: 'span',
-      _key: 'b1c2',
-      text: 'bar',
-      marks: [],
-    },
-  ],
-  markDefs: [],
-  style: 'normal',
-}
-const b2: PortableTextBlock = {
-  _type: 'image',
-  _key: 'b2',
-  src: 'https://example.com/image.jpg',
-  alt: 'Example',
-}
-const b3: PortableTextTextBlock = {
-  _type: 'block',
-  _key: 'b3',
-  children: [
-    {
-      _type: 'span',
-      _key: 'b3c1',
-      text: 'baz',
-      marks: [],
-    },
-  ],
-  markDefs: [],
-  style: 'normal',
-}
-const b4: PortableTextTextBlock = {
-  _type: 'block',
-  _key: 'b4',
-  children: [
-    {
-      _type: 'span',
-      _key: 'b4c1',
-      text: 'fizz',
-      marks: [],
-    },
-    {
-      _type: 'stock-ticker',
-      _key: 'b4c2',
-      symbol: 'AAPL',
-    },
-    {
-      _type: 'span',
-      _key: 'b4c3',
-      text: 'buzz',
-      marks: [],
-    },
-  ],
-  markDefs: [],
-  style: 'normal',
-}
-
-const schema = compileSchema(
-  defineSchema({
-    blockObjects: [{name: 'image'}],
-    inlineObjects: [{name: 'stock-ticker'}],
-  }),
-)
-const blocks: Array<PortableTextBlock> = [b1, b2, b3, b4]
-
-describe(sliceBlocks.name, () => {
-  test('sensible defaults', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: null,
-        },
-        blocks: [],
-      }),
-    ).toEqual([])
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: null,
-        },
-        blocks,
-      }),
-    ).toEqual([])
-  })
-
-  test('slicing a single block', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b1._key}, 'children', {_key: b1.children[0]._key}],
-              offset: 0,
-            },
-            focus: {
-              path: [{_key: b1._key}, 'children', {_key: b1.children[0]._key}],
-              offset: 3,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([
-      {
-        ...b1,
-        children: [b1.children[0]],
-      },
-    ])
-  })
-
-  test('slicing a single span', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b1._key}, 'children', {_key: b1.children[0]._key}],
-              offset: 1,
-            },
-            focus: {
-              path: [{_key: b1._key}, 'children', {_key: b1.children[0]._key}],
-              offset: 2,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([
-      {
-        ...b1,
-        children: [
-          {
-            ...b1.children[0],
-            text: 'o',
-          },
-        ],
-      },
-    ])
-  })
-
-  test('starting and ending selection on a block object', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b2._key}],
-              offset: 0,
-            },
-            focus: {
-              path: [{_key: b2._key}],
-              offset: 0,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([b2])
-  })
-
-  test('starting selection on a block object', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b2._key}],
-              offset: 0,
-            },
-            focus: {
-              path: [{_key: b3._key}, 'children', {_key: b3.children[0]._key}],
-              offset: 3,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([b2, b3])
-  })
-
-  test('ending selection on a block object', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b1._key}, 'children', {_key: b1.children[0]._key}],
-              offset: 3,
-            },
-            focus: {
-              path: [{_key: b2._key}],
-              offset: 0,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([
-      {
-        ...b1,
-        children: [
-          {
-            ...b1.children[0],
-            text: '',
-          },
-          ...b1.children.slice(1),
-        ],
-      },
-      blocks[1],
-    ])
-  })
-
-  test('slicing across block object', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b1._key}, 'children', {_key: b1.children[0]._key}],
-              offset: 0,
-            },
-            focus: {
-              path: [{_key: b3._key}, 'children', {_key: b3.children[0]._key}],
-              offset: 3,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([b1, b2, b3])
-  })
-
-  test('starting and ending mid-span', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b3._key}, 'children', {_key: b3.children[0]._key}],
-              offset: 2,
-            },
-            focus: {
-              path: [{_key: b4._key}, 'children', {_key: b4.children[0]._key}],
-              offset: 1,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([
-      {
-        ...b3,
-        children: [
-          {
-            ...b3.children[0],
-            text: 'z',
-          },
-        ],
-      },
-      {
-        ...b4,
-        children: [
-          {
-            ...b4.children[0],
-            text: 'f',
-          },
-        ],
-      },
-    ])
-  })
-
-  test('starting mid-span and ending end-span', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b3._key}, 'children', {_key: b3.children[0]._key}],
-              offset: 2,
-            },
-            focus: {
-              path: [{_key: b4._key}, 'children', {_key: b4.children[0]._key}],
-              offset: 4,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([
-      {
-        ...b3,
-        children: [
-          {
-            ...b3.children[0],
-            text: 'z',
-          },
-        ],
-      },
-      {
-        ...b4,
-        children: [
-          {
-            ...b4.children[0],
-          },
-        ],
-      },
-    ])
-  })
-
-  test('starting on inline object', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b4._key}, 'children', {_key: b4.children[1]._key}],
-              offset: 0,
-            },
-            focus: {
-              path: [{_key: b4._key}, 'children', {_key: b4.children[2]._key}],
-              offset: 4,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([
-      {
-        ...b4,
-        children: [b4.children[1], b4.children[2]],
-      },
-    ])
-  })
-
-  test('ending on inline object', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b4._key}, 'children', {_key: b4.children[0]._key}],
-              offset: 0,
-            },
-            focus: {
-              path: [{_key: b4._key}, 'children', {_key: b4.children[1]._key}],
-              offset: 0,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([
-      {
-        ...b4,
-        children: [b4.children[0], b4.children[1]],
-      },
-    ])
-  })
-
-  test('starting and ending on inline object', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: b4._key}, 'children', {_key: b4.children[1]._key}],
-              offset: 0,
-            },
-            focus: {
-              path: [{_key: b4._key}, 'children', {_key: b4.children[1]._key}],
-              offset: 0,
-            },
-          },
-        },
-        blocks,
-      }),
-    ).toEqual([
-      {
-        ...b4,
-        children: [b4.children[1]],
-      },
-    ])
-  })
-
-  test('slicing text block with custom props', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: 'b0'}, 'children', {_key: 's0'}],
-              offset: 7,
-            },
-            focus: {
-              path: [{_key: 'b0'}, 'children', {_key: 's0'}],
-              offset: 12,
-            },
-          },
-        },
-        blocks: [
-          {
-            _key: 'b0',
-            _type: 'block',
-            children: [
-              {_key: 's0', _type: 'span', text: 'Hello, world!', marks: []},
-            ],
-            markDefs: [],
-            style: 'normal',
-            _map: {},
-          },
-        ],
-      }),
-    ).toEqual([
-      {
-        _key: 'b0',
-        _type: 'block',
-        children: [{_key: 's0', _type: 'span', text: 'world', marks: []}],
-        markDefs: [],
-        style: 'normal',
-        _map: {},
-      },
-    ])
-  })
-
-  test('slicing span with custom props', () => {
-    expect(
-      sliceBlocks({
-        context: {
-          schema,
-          selection: {
-            anchor: {
-              path: [{_key: 'b0'}, 'children', {_key: 's0'}],
-              offset: 7,
-            },
-            focus: {
-              path: [{_key: 'b0'}, 'children', {_key: 's0'}],
-              offset: 12,
-            },
-          },
-        },
-        blocks: [
-          {
-            _key: 'b0',
-            _type: 'block',
-            children: [
-              {
-                _key: 's0',
-                _type: 'span',
-                text: 'Hello, world!',
-                _map: {},
-                marks: [],
-              },
-            ],
-            markDefs: [],
-            style: 'normal',
-          },
-        ],
-      }),
-    ).toEqual([
-      {
-        _key: 'b0',
-        _type: 'block',
-        children: [
-          {_key: 's0', _type: 'span', text: 'world', _map: {}, marks: []},
-        ],
-        markDefs: [],
-        style: 'normal',
-      },
-    ])
-  })
-})