@portabletext/editor 1.48.7 → 1.48.8

package/src/utils/util.child-selection-point-to-block-offset.ts

@@ -1,8 +1,5 @@
-import {
-  isPortableTextSpan,
-  isPortableTextTextBlock,
-  type PortableTextBlock,
-} from '@sanity/types'
+import type {EditorContext} from '../editor/editor-snapshot'
+import {isSpan, isTextBlock} from '../internal-utils/parse-blocks'
 import type {BlockOffset} from '../types/block-offset'
 import type {EditorSelectionPoint} from '../types/editor'
 import {isKeyedSegment} from './util.is-keyed-segment'
@@ -11,10 +8,10 @@ import {isKeyedSegment} from './util.is-keyed-segment'
  * @public
  */
 export function childSelectionPointToBlockOffset({
-  value,
+  context,
   selectionPoint,
 }: {
-  value: Array<PortableTextBlock>
+  context: Pick<EditorContext, 'schema' | 'value'>
   selectionPoint: EditorSelectionPoint
 }): BlockOffset | undefined {
   let offset = 0
@@ -30,12 +27,12 @@ export function childSelectionPointToBlockOffset({
     return undefined
   }
 
-  for (const block of value) {
+  for (const block of context.value) {
     if (block._key !== blockKey) {
       continue
     }
 
-    if (!isPortableTextTextBlock(block)) {
+    if (!isTextBlock(context, block)) {
       continue
     }
 
@@ -47,7 +44,7 @@ export function childSelectionPointToBlockOffset({
         }
       }
 
-      if (isPortableTextSpan(child)) {
+      if (isSpan(context, child)) {
         offset += child.text.length
       }
     }

package/src/utils/util.get-block-end-point.ts

@@ -1,34 +1,34 @@
-import {
-  isPortableTextSpan,
-  isPortableTextTextBlock,
-  type KeyedSegment,
-  type PortableTextBlock,
-} from '@sanity/types'
+import type {KeyedSegment, PortableTextBlock} from '@sanity/types'
+import type {EditorContext} from '../editor/editor-snapshot'
+import {isSpan, isTextBlock} from '../internal-utils/parse-blocks'
 import type {EditorSelectionPoint} from '../types/editor'
 
 /**
  * @public
  */
 export function getBlockEndPoint({
-  node,
-  path,
+  context,
+  block,
 }: {
-  node: PortableTextBlock
-  path: [KeyedSegment]
+  context: Pick<EditorContext, 'schema'>
+  block: {
+    node: PortableTextBlock
+    path: [KeyedSegment]
+  }
 }): EditorSelectionPoint {
-  if (isPortableTextTextBlock(node)) {
-    const lastChild = node.children[node.children.length - 1]
+  if (isTextBlock(context, block.node)) {
+    const lastChild = block.node.children[block.node.children.length - 1]
 
     if (lastChild) {
       return {
-        path: [...path, 'children', {_key: lastChild._key}],
-        offset: isPortableTextSpan(lastChild) ? lastChild.text.length : 0,
+        path: [...block.path, 'children', {_key: lastChild._key}],
+        offset: isSpan(context, lastChild) ? lastChild.text.length : 0,
       }
     }
   }
 
   return {
-    path,
+    path: block.path,
     offset: 0,
   }
 }

package/src/utils/util.get-block-start-point.ts

@@ -1,29 +1,30 @@
-import {
-  isPortableTextTextBlock,
-  type KeyedSegment,
-  type PortableTextBlock,
-} from '@sanity/types'
+import type {KeyedSegment, PortableTextBlock} from '@sanity/types'
+import type {EditorContext} from '../editor/editor-snapshot'
+import {isTextBlock} from '../internal-utils/parse-blocks'
 import type {EditorSelectionPoint} from '../types/editor'
 
 /**
  * @public
  */
 export function getBlockStartPoint({
-  node,
-  path,
+  context,
+  block,
 }: {
-  node: PortableTextBlock
-  path: [KeyedSegment]
+  context: Pick<EditorContext, 'schema'>
+  block: {
+    node: PortableTextBlock
+    path: [KeyedSegment]
+  }
 }): EditorSelectionPoint {
-  if (isPortableTextTextBlock(node)) {
+  if (isTextBlock(context, block.node)) {
     return {
-      path: [...path, 'children', {_key: node.children[0]._key}],
+      path: [...block.path, 'children', {_key: block.node.children[0]._key}],
       offset: 0,
     }
   }
 
   return {
-    path,
+    path: block.path,
     offset: 0,
   }
 }

package/src/utils/util.is-empty-text-block.ts

@@ -1,19 +1,20 @@
-import {
-  isPortableTextSpan,
-  isPortableTextTextBlock,
-  type PortableTextBlock,
-} from '@sanity/types'
+import type {PortableTextBlock} from '@sanity/types'
+import type {EditorContext} from '../editor/editor-snapshot'
+import {isSpan, isTextBlock} from '../internal-utils/parse-blocks'
 import {getTextBlockText} from './util.get-text-block-text'
 
 /**
  * @public
  */
-export function isEmptyTextBlock(block: PortableTextBlock) {
-  if (!isPortableTextTextBlock(block)) {
+export function isEmptyTextBlock(
+  context: Pick<EditorContext, 'schema'>,
+  block: PortableTextBlock,
+) {
+  if (!isTextBlock(context, block)) {
     return false
   }
 
-  const onlyText = block.children.every(isPortableTextSpan)
+  const onlyText = block.children.every((child) => isSpan(context, child))
   const blockText = getTextBlockText(block)
 
   return onlyText && blockText === ''

package/src/utils/util.selection-point-to-block-offset.ts

@@ -1,4 +1,4 @@
-import type {PortableTextBlock} from '@sanity/types'
+import type {EditorContext} from '../editor/editor-snapshot'
 import type {BlockOffset} from '../types/block-offset'
 import type {EditorSelectionPoint} from '../types/editor'
 import {childSelectionPointToBlockOffset} from './util.child-selection-point-to-block-offset'
@@ -8,10 +8,10 @@ import {isKeyedSegment} from './util.is-keyed-segment'
  * @public
  */
 export function selectionPointToBlockOffset({
-  value,
+  context,
   selectionPoint,
 }: {
-  value: Array<PortableTextBlock>
+  context: Pick<EditorContext, 'schema' | 'value'>
   selectionPoint: EditorSelectionPoint
 }): BlockOffset | undefined {
   if (
@@ -25,7 +25,7 @@ export function selectionPointToBlockOffset({
   }
 
   return childSelectionPointToBlockOffset({
-    value,
+    context,
     selectionPoint,
   })
 }

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

@@ -1,5 +1,6 @@
 import type {PortableTextBlock, PortableTextTextBlock} from '@sanity/types'
 import {describe, expect, test} from 'vitest'
+import {compileSchemaDefinition, defineSchema} from '../editor/editor-schema'
 import {sliceBlocks} from './util.slice-blocks'
 
 const b1: PortableTextTextBlock = {
@@ -57,28 +58,48 @@ const b4: PortableTextTextBlock = {
   ],
 }
 
+const schema = compileSchemaDefinition(defineSchema({}))
 const blocks: Array<PortableTextBlock> = [b1, b2, b3, b4]
 
 describe(sliceBlocks.name, () => {
   test('sensible defaults', () => {
-    expect(sliceBlocks({blocks: [], selection: null})).toEqual([])
-    expect(sliceBlocks({blocks, selection: null})).toEqual([])
+    expect(
+      sliceBlocks({
+        context: {
+          schema,
+          selection: null,
+        },
+        blocks: [],
+      }),
+    ).toEqual([])
+    expect(
+      sliceBlocks({
+        context: {
+          schema,
+          selection: null,
+        },
+        blocks,
+      }),
+    ).toEqual([])
   })
 
   test('slicing a single block', () => {
     expect(
       sliceBlocks({
-        blocks,
-        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,
+        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([
       {
@@ -91,17 +112,20 @@ describe(sliceBlocks.name, () => {
   test('slicing a single span', () => {
     expect(
       sliceBlocks({
-        blocks,
-        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,
+        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([
       {
@@ -119,17 +143,20 @@ describe(sliceBlocks.name, () => {
   test('starting and ending selection on a block object', () => {
     expect(
       sliceBlocks({
-        blocks,
-        selection: {
-          anchor: {
-            path: [{_key: b2._key}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: b2._key}],
-            offset: 0,
+        context: {
+          schema,
+          selection: {
+            anchor: {
+              path: [{_key: b2._key}],
+              offset: 0,
+            },
+            focus: {
+              path: [{_key: b2._key}],
+              offset: 0,
+            },
           },
         },
+        blocks,
       }),
     ).toEqual([b2])
   })
@@ -137,17 +164,20 @@ describe(sliceBlocks.name, () => {
   test('starting selection on a block object', () => {
     expect(
       sliceBlocks({
-        blocks,
-        selection: {
-          anchor: {
-            path: [{_key: b2._key}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: b3._key}, 'children', {_key: b3.children[0]._key}],
-            offset: 3,
+        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])
   })
@@ -155,17 +185,20 @@ describe(sliceBlocks.name, () => {
   test('ending selection on a block object', () => {
     expect(
       sliceBlocks({
-        blocks,
-        selection: {
-          anchor: {
-            path: [{_key: b1._key}, 'children', {_key: b1.children[0]._key}],
-            offset: 3,
-          },
-          focus: {
-            path: [{_key: b2._key}],
-            offset: 0,
+        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([
       {
@@ -185,17 +218,20 @@ describe(sliceBlocks.name, () => {
   test('slicing across block object', () => {
     expect(
       sliceBlocks({
-        blocks,
-        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,
+        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])
   })
@@ -203,17 +239,20 @@ describe(sliceBlocks.name, () => {
   test('starting and ending mid-span', () => {
     expect(
       sliceBlocks({
-        blocks,
-        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,
+        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([
       {
@@ -240,17 +279,20 @@ describe(sliceBlocks.name, () => {
   test('starting mid-span and ending end-span', () => {
     expect(
       sliceBlocks({
-        blocks,
-        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,
+        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([
       {
@@ -276,17 +318,20 @@ describe(sliceBlocks.name, () => {
   test('starting on inline object', () => {
     expect(
       sliceBlocks({
-        blocks,
-        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,
+        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([
       {
@@ -299,17 +344,20 @@ describe(sliceBlocks.name, () => {
   test('ending on inline object', () => {
     expect(
       sliceBlocks({
-        blocks,
-        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,
+        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([
       {
@@ -322,17 +370,20 @@ describe(sliceBlocks.name, () => {
   test('starting and ending on inline object', () => {
     expect(
       sliceBlocks({
-        blocks,
-        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,
+        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([
       {
@@ -345,6 +396,19 @@ describe(sliceBlocks.name, () => {
   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',
@@ -353,16 +417,6 @@ describe(sliceBlocks.name, () => {
             _map: {},
           },
         ],
-        selection: {
-          anchor: {
-            path: [{_key: 'b0'}, 'children', {_key: 's0'}],
-            offset: 7,
-          },
-          focus: {
-            path: [{_key: 'b0'}, 'children', {_key: 's0'}],
-            offset: 12,
-          },
-        },
       }),
     ).toEqual([
       {
@@ -377,6 +431,19 @@ describe(sliceBlocks.name, () => {
   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',
@@ -386,16 +453,6 @@ describe(sliceBlocks.name, () => {
             ],
           },
         ],
-        selection: {
-          anchor: {
-            path: [{_key: 'b0'}, 'children', {_key: 's0'}],
-            offset: 7,
-          },
-          focus: {
-            path: [{_key: 'b0'}, 'children', {_key: 's0'}],
-            offset: 12,
-          },
-        },
       }),
     ).toEqual([
       {