@portabletext/editor 1.39.1 → 1.40.1

package/src/internal-utils/terse-pt.ts

@@ -0,0 +1,36 @@
+import {isPortableTextBlock, isPortableTextSpan} from '@portabletext/toolkit'
+import type {PortableTextBlock} from '@sanity/types'
+
+export function getTersePt(value: Array<PortableTextBlock> | undefined) {
+  if (!value) {
+    return undefined
+  }
+
+  const blocks: Array<string> = []
+
+  for (const block of value) {
+    if (blocks.length > 0) {
+      blocks.push('|')
+    }
+    if (isPortableTextBlock(block)) {
+      for (const child of block.children) {
+        if (isPortableTextSpan(child)) {
+          blocks.push(child.text)
+        } else {
+          blocks.push(`[${child._type}]`)
+        }
+      }
+    } else {
+      blocks.push(`[${block._type}]`)
+    }
+  }
+
+  return blocks
+}
+
+export function parseTersePt(text: string) {
+  return text
+    .replace(/\|/g, ',|,')
+    .split(',')
+    .map((span) => span.replace(/\\n/g, '\n'))
+}

package/src/internal-utils/text-block-key.test.ts

@@ -0,0 +1,30 @@
+import {expect, test} from 'vitest'
+import {getTextBlockKey} from './text-block-key'
+
+test(getTextBlockKey.name, () => {
+  const emptyBlock = {
+    _key: 'b1',
+    _type: 'block',
+    children: [{_key: 's1', _type: 'span', text: ''}],
+  }
+  const fooBlock = {
+    _key: 'b2',
+    _type: 'block',
+    children: [{_key: 's2', _type: 'span', text: 'foo'}],
+  }
+  const softReturnBlock = {
+    _key: 'b3',
+    _type: 'block',
+    children: [{_key: 's3', _type: 'span', text: 'foo\nbar'}],
+  }
+
+  expect(getTextBlockKey([emptyBlock, fooBlock, softReturnBlock], '')).toBe(
+    'b1',
+  )
+  expect(getTextBlockKey([emptyBlock, fooBlock, softReturnBlock], 'foo')).toBe(
+    'b2',
+  )
+  expect(
+    getTextBlockKey([emptyBlock, fooBlock, softReturnBlock], 'foo\nbar'),
+  ).toBe('b3')
+})

package/src/internal-utils/text-block-key.ts

@@ -0,0 +1,30 @@
+import {isPortableTextBlock} from '@portabletext/toolkit'
+import {isPortableTextSpan, type PortableTextBlock} from '@sanity/types'
+
+export function getTextBlockKey(
+  value: Array<PortableTextBlock> | undefined,
+  text: string,
+) {
+  if (!value) {
+    throw new Error(`Unable to find block key for text "${text}"`)
+  }
+
+  let blockKey: string | undefined
+
+  for (const block of value) {
+    if (isPortableTextBlock(block)) {
+      for (const child of block.children) {
+        if (isPortableTextSpan(child) && child.text === text) {
+          blockKey = block._key
+          break
+        }
+      }
+    }
+  }
+
+  if (!blockKey) {
+    throw new Error(`Unable to find block key for text "${text}"`)
+  }
+
+  return blockKey
+}

package/src/internal-utils/text-marks.test.ts

@@ -0,0 +1,33 @@
+import {expect, test} from 'vitest'
+import {getTextMarks} from './text-marks'
+
+test(getTextMarks.name, () => {
+  const fooBlock = {
+    _key: 'b1',
+    _type: 'block',
+    children: [{_key: 's1', _type: 'span', text: 'foo'}],
+  }
+  const splitBarBlock = {
+    _key: 'b1',
+    _type: 'block',
+    children: [
+      {_key: 's1', _type: 'span', text: 'ba', marks: ['strong']},
+      {_key: 's2', _type: 'span', text: 'r'},
+    ],
+  }
+  const splitFooBarBazBlock = {
+    _key: 'b1',
+    _type: 'block',
+    children: [
+      {_key: 's1', _type: 'span', text: 'foo '},
+      {_key: 's2', _type: 'span', text: 'bar', marks: ['strong']},
+      {_key: 's3', _type: 'span', text: ' '},
+      {_key: 's4', _type: 'span', text: 'baz', marks: ['l1']},
+    ],
+  }
+
+  expect(getTextMarks([fooBlock, splitBarBlock], 'ba')).toEqual(['strong'])
+  expect(getTextMarks([splitFooBarBazBlock], 'bar')).toEqual(['strong'])
+  expect(getTextMarks([splitFooBarBazBlock], ' ')).toEqual([])
+  expect(getTextMarks([splitFooBarBazBlock], 'baz')).toEqual(['l1'])
+})

package/src/internal-utils/text-marks.ts

@@ -0,0 +1,26 @@
+import {isPortableTextBlock, isPortableTextSpan} from '@portabletext/toolkit'
+import type {PortableTextBlock} from '@sanity/types'
+
+export function getTextMarks(
+  value: Array<PortableTextBlock> | undefined,
+  text: string,
+) {
+  if (!value) {
+    return undefined
+  }
+
+  let marks: Array<string> | undefined = undefined
+
+  for (const block of value) {
+    if (isPortableTextBlock(block)) {
+      for (const child of block.children) {
+        if (isPortableTextSpan(child) && child.text === text) {
+          marks = child.marks ?? []
+          break
+        }
+      }
+    }
+  }
+
+  return marks
+}

package/src/internal-utils/text-selection.test.ts

@@ -0,0 +1,175 @@
+import {expect, test} from 'vitest'
+import {
+  getSelectionAfterText,
+  getSelectionBeforeText,
+  getTextSelection,
+} from './text-selection'
+
+test(getTextSelection.name, () => {
+  const joinedBlock = {
+    _key: 'b1',
+    _type: 'block',
+    children: [{_key: 's1', _type: 'span', text: 'foo bar baz'}],
+  }
+
+  expect(getTextSelection([joinedBlock], 'foo ')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 4},
+  })
+  expect(getTextSelection([joinedBlock], 'o')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 1},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 2},
+  })
+  expect(getTextSelection([joinedBlock], 'bar')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 4},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 7},
+  })
+  expect(getTextSelection([joinedBlock], ' baz')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 7},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 11},
+  })
+
+  const noSpaceBlock = {
+    _key: 'b1',
+    _type: 'block',
+    children: [
+      {_key: 's1', _type: 'span', text: 'foo'},
+      {_key: 's2', _type: 'span', text: 'bar'},
+    ],
+  }
+
+  expect(getTextSelection([noSpaceBlock], 'obar')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 2},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 3},
+  })
+
+  const emptyLineBlock = {
+    _key: 'b1',
+    _type: 'block',
+    children: [
+      {_key: 's1', _type: 'span', text: 'foo'},
+      {_key: 's2', _type: 'span', text: ''},
+      {_key: 's3', _type: 'span', text: 'bar'},
+    ],
+  }
+
+  expect(getTextSelection([emptyLineBlock], 'foobar')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 3},
+  })
+
+  const splitBlock = {
+    _key: 'b1',
+    _type: 'block',
+    children: [
+      {_key: 's1', _type: 'span', text: 'foo '},
+      {_key: 's2', _type: 'span', text: 'bar'},
+      {_key: 's3', _type: 'span', text: ' baz'},
+    ],
+  }
+
+  expect(getTextSelection([splitBlock], 'foo')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 3},
+  })
+  expect(getTextSelection([splitBlock], 'bar')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 0},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 3},
+  })
+  expect(getTextSelection([splitBlock], 'baz')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 1},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
+  })
+  expect(getTextSelection([splitBlock], 'foo bar baz')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
+  })
+  expect(getTextSelection([splitBlock], 'o bar b')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 2},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 2},
+  })
+
+  const twoBlocks = [
+    {
+      _key: 'b1',
+      _type: 'block',
+      children: [{_key: 's1', _type: 'span', text: 'foo'}],
+    },
+    {
+      _key: 'b2',
+      _type: 'block',
+      children: [{_key: 's2', _type: 'span', text: 'bar'}],
+    },
+  ]
+
+  expect(getTextSelection(twoBlocks, 'ooba')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 1},
+    focus: {path: [{_key: 'b2'}, 'children', {_key: 's2'}], offset: 2},
+  })
+})
+
+test(getSelectionBeforeText.name, () => {
+  const splitBlock = {
+    _type: 'block',
+    _key: 'b1',
+    children: [
+      {_type: 'span', _key: 's1', text: 'foo '},
+      {_type: 'span', _key: 's2', text: 'bar'},
+      {_type: 'span', _key: 's3', text: ' baz'},
+    ],
+  }
+
+  expect(getSelectionBeforeText([splitBlock], 'foo ')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+    backward: false,
+  })
+  expect(getSelectionBeforeText([splitBlock], 'f')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
+    backward: false,
+  })
+  expect(getSelectionBeforeText([splitBlock], 'o')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 1},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 1},
+    backward: false,
+  })
+  expect(getSelectionBeforeText([splitBlock], 'bar')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 0},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 0},
+    backward: false,
+  })
+  expect(getSelectionBeforeText([splitBlock], ' baz')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 0},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 0},
+    backward: false,
+  })
+})
+
+test(getSelectionAfterText.name, () => {
+  const splitBlock = {
+    _type: 'block',
+    _key: 'b1',
+    children: [
+      {_type: 'span', _key: 's1', text: 'foo '},
+      {_type: 'span', _key: 's2', text: 'bar'},
+      {_type: 'span', _key: 's3', text: ' baz'},
+    ],
+  }
+
+  expect(getSelectionAfterText([splitBlock], 'foo ')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 4},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 4},
+    backward: false,
+  })
+  expect(getSelectionAfterText([splitBlock], 'bar')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 3},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's2'}], offset: 3},
+    backward: false,
+  })
+  expect(getSelectionAfterText([splitBlock], ' baz')).toEqual({
+    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
+    focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
+    backward: false,
+  })
+})

package/src/internal-utils/text-selection.ts

@@ -0,0 +1,122 @@
+import {isPortableTextBlock, isPortableTextSpan} from '@portabletext/toolkit'
+import type {PortableTextBlock} from '@sanity/types'
+import type {EditorSelection, EditorSelectionPoint} from '../types/editor'
+import {collapseSelection} from './collapse-selection'
+import {splitString} from './split-string'
+import {stringOverlap} from './string-overlap'
+
+export function getTextSelection(
+  value: Array<PortableTextBlock> | undefined,
+  text: string,
+): EditorSelection {
+  if (!value) {
+    throw new Error(`Unable to find selection for value ${value}`)
+  }
+
+  let anchor: EditorSelectionPoint | undefined
+  let focus: EditorSelectionPoint | undefined
+
+  for (const block of value) {
+    if (isPortableTextBlock(block)) {
+      for (const child of block.children) {
+        if (isPortableTextSpan(child)) {
+          if (child.text === text) {
+            anchor = {
+              path: [{_key: block._key}, 'children', {_key: child._key}],
+              offset: 0,
+            }
+            focus = {
+              path: [{_key: block._key}, 'children', {_key: child._key}],
+              offset: text.length,
+            }
+            break
+          }
+
+          const splitChildText = splitString(child.text, text)
+
+          if (splitChildText[0] === '' && splitChildText[1] !== '') {
+            anchor = {
+              path: [{_key: block._key}, 'children', {_key: child._key}],
+              offset: 0,
+            }
+            focus = {
+              path: [{_key: block._key}, 'children', {_key: child._key}],
+              offset: text.length,
+            }
+            break
+          }
+
+          if (
+            splitChildText[0] !== '' &&
+            splitChildText[1] === '' &&
+            child.text.indexOf(text) !== -1
+          ) {
+            anchor = {
+              path: [{_key: block._key}, 'children', {_key: child._key}],
+              offset: child.text.length - text.length,
+            }
+            focus = {
+              path: [{_key: block._key}, 'children', {_key: child._key}],
+              offset: child.text.length,
+            }
+            break
+          }
+
+          if (splitChildText[0] !== '' && splitChildText[1] !== '') {
+            anchor = {
+              path: [{_key: block._key}, 'children', {_key: child._key}],
+              offset: splitChildText[0].length,
+            }
+            focus = {
+              path: [{_key: block._key}, 'children', {_key: child._key}],
+              offset: splitChildText[0].length + text.length,
+            }
+            break
+          }
+
+          const overlap = stringOverlap(child.text, text)
+
+          if (overlap !== '') {
+            if (child.text.lastIndexOf(overlap) >= 0 && !anchor) {
+              anchor = {
+                path: [{_key: block._key}, 'children', {_key: child._key}],
+                offset: child.text.lastIndexOf(overlap),
+              }
+              continue
+            }
+
+            if (child.text.indexOf(overlap) === 0) {
+              focus = {
+                path: [{_key: block._key}, 'children', {_key: child._key}],
+                offset: overlap.length,
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (!anchor || !focus) {
+    throw new Error(`Unable to find selection for text "${text}"`)
+  }
+
+  return {
+    anchor,
+    focus,
+  }
+}
+
+export function getSelectionBeforeText(
+  value: Array<PortableTextBlock> | undefined,
+  text: string,
+): EditorSelection {
+  return collapseSelection(getTextSelection(value, text), 'start')
+}
+
+export function getSelectionAfterText(
+  value: Array<PortableTextBlock> | undefined,
+  text: string,
+): EditorSelection {
+  return collapseSelection(getTextSelection(value, text), 'end')
+}

package/src/internal-utils/value-annotations.ts

@@ -0,0 +1,31 @@
+import {isPortableTextBlock, isPortableTextSpan} from '@portabletext/toolkit'
+import type {PortableTextBlock} from '@sanity/types'
+
+export function getValueAnnotations(
+  value: Array<PortableTextBlock> | undefined,
+): Array<string> {
+  if (!value) {
+    return []
+  }
+
+  const annotations: Array<string> = []
+
+  for (const block of value) {
+    if (isPortableTextBlock(block)) {
+      for (const child of block.children) {
+        if (isPortableTextSpan(child) && child.marks) {
+          for (const mark of child.marks) {
+            if (
+              block.markDefs?.some((markDef) => markDef._key === mark) &&
+              !annotations.includes(mark)
+            ) {
+              annotations.push(mark)
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return annotations
+}

package/src/internal-utils/values.ts

@@ -37,9 +37,6 @@ export function toSlateValue(
   if (value && Array.isArray(value)) {
     return value.map((block) => {
       const {_type, _key, ...rest} = block
-      const voidChildren = [
-        {_key: VOID_CHILD_KEY, _type: 'span', text: '', marks: []},
-      ]
       const isPortableText = block && block._type === schemaTypes.block.name
       if (isPortableText) {
         const textBlock = block as PortableTextTextBlock
@@ -61,7 +58,14 @@ export function toSlateValue(
               {
                 _type: cType,
                 _key: cKey,
-                children: voidChildren,
+                children: [
+                  {
+                    _key: VOID_CHILD_KEY,
+                    _type: 'span',
+                    text: '',
+                    marks: [],
+                  },
+                ],
                 value: cRest,
                 __inline: true,
               },
@@ -92,7 +96,14 @@ export function toSlateValue(
         {
           _type,
           _key,
-          children: voidChildren,
+          children: [
+            {
+              _key: VOID_CHILD_KEY,
+              _type: 'span',
+              text: '',
+              marks: [],
+            },
+          ],
           value: rest,
         },
         keyMap,

package/src/utils/index.ts

@@ -2,6 +2,8 @@ export {
   blockOffsetToSpanSelectionPoint,
   spanSelectionPointToBlockOffset,
 } from './util.block-offset'
+export {blockOffsetToBlockSelectionPoint} from './util.block-offset-to-block-selection-point'
+export {blockOffsetToSelectionPoint} from './util.block-offset-to-selection-point'
 export {blockOffsetsToSelection} from './util.block-offsets-to-selection'
 export {childSelectionPointToBlockOffset} from './util.child-selection-point-to-block-offset'
 export {getBlockEndPoint} from './util.get-block-end-point'
@@ -9,10 +11,13 @@ export {getBlockStartPoint} from './util.get-block-start-point'
 export {getTextBlockText} from './util.get-text-block-text'
 export {isEmptyTextBlock} from './util.is-empty-text-block'
 export {isEqualSelectionPoints} from './util.is-equal-selection-points'
+export {isEqualSelections} from './util.is-equal-selections'
 export {isKeyedSegment} from './util.is-keyed-segment'
+export {isSelectionCollapsed} from './util.is-selection-collapsed'
 export {isSpan} from './util.is-span'
 export {isTextBlock} from './util.is-text-block'
 export {mergeTextBlocks} from './util.merge-text-blocks'
 export {reverseSelection} from './util.reverse-selection'
+export {selectionPointToBlockOffset} from './util.selection-point-to-block-offset'
 export {sliceBlocks} from './util.slice-blocks'
 export {splitTextBlock} from './util.split-text-block'

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

@@ -0,0 +1,28 @@
+import type {PortableTextBlock} from '@sanity/types'
+import type {BlockOffset} from '../types/block-offset'
+import type {EditorSelectionPoint} from '../types/editor'
+
+/**
+ * @public
+ */
+export function blockOffsetToBlockSelectionPoint({
+  value,
+  blockOffset,
+}: {
+  value: Array<PortableTextBlock>
+  blockOffset: BlockOffset
+}): EditorSelectionPoint | undefined {
+  let selectionPoint: EditorSelectionPoint | undefined
+
+  for (const block of value) {
+    if (block._key === blockOffset.path[0]._key) {
+      selectionPoint = {
+        path: [{_key: block._key}],
+        offset: blockOffset.offset,
+      }
+      break
+    }
+  }
+
+  return selectionPoint
+}

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

@@ -0,0 +1,33 @@
+import type {PortableTextBlock} from '@sanity/types'
+import type {BlockOffset} from '../types/block-offset'
+import type {EditorSelectionPoint} from '../types/editor'
+import {blockOffsetToSpanSelectionPoint} from './util.block-offset'
+import {blockOffsetToBlockSelectionPoint} from './util.block-offset-to-block-selection-point'
+
+/**
+ * @public
+ */
+export function blockOffsetToSelectionPoint({
+  value,
+  blockOffset,
+  direction,
+}: {
+  value: Array<PortableTextBlock>
+  blockOffset: BlockOffset
+  direction: 'forward' | 'backward'
+}): EditorSelectionPoint | undefined {
+  const spanSelectionPoint = blockOffsetToSpanSelectionPoint({
+    value,
+    blockOffset,
+    direction,
+  })
+
+  if (!spanSelectionPoint) {
+    return blockOffsetToBlockSelectionPoint({
+      value,
+      blockOffset,
+    })
+  }
+
+  return spanSelectionPoint
+}

package/src/utils/util.block-offsets-to-selection.ts

@@ -1,7 +1,7 @@
 import type {PortableTextBlock} from '@sanity/types'
 import type {EditorSelection} from '..'
 import type {BlockOffset} from '../types/block-offset'
-import {blockOffsetToSpanSelectionPoint} from './util.block-offset'
+import {blockOffsetToSelectionPoint} from './util.block-offset-to-selection-point'
 
 /**
  * @public
@@ -15,12 +15,12 @@ export function blockOffsetsToSelection({
   offsets: {anchor: BlockOffset; focus: BlockOffset}
   backward?: boolean
 }): EditorSelection {
-  const anchor = blockOffsetToSpanSelectionPoint({
+  const anchor = blockOffsetToSelectionPoint({
     value,
     blockOffset: offsets.anchor,
     direction: backward ? 'backward' : 'forward',
   })
-  const focus = blockOffsetToSpanSelectionPoint({
+  const focus = blockOffsetToSelectionPoint({
     value,
     blockOffset: offsets.focus,
     direction: backward ? 'forward' : 'backward',

package/src/utils/util.is-equal-selections.ts

@@ -0,0 +1,20 @@
+import type {EditorSelection} from '../types/editor'
+import {isEqualSelectionPoints} from './util.is-equal-selection-points'
+
+/**
+ * @public
+ */
+export function isEqualSelections(a: EditorSelection, b: EditorSelection) {
+  if (!a && !b) {
+    return true
+  }
+
+  if (!a || !b) {
+    return false
+  }
+
+  return (
+    isEqualSelectionPoints(a.anchor, b.anchor) &&
+    isEqualSelectionPoints(a.focus, b.focus)
+  )
+}

package/src/utils/util.is-selection-collapsed.ts

@@ -0,0 +1,15 @@
+import type {EditorSelection} from '../types/editor'
+
+/**
+ * @public
+ */
+export function isSelectionCollapsed(selection: EditorSelection) {
+  if (!selection) {
+    return false
+  }
+
+  return (
+    selection.anchor.path.join() === selection.focus.path.join() &&
+    selection.anchor.offset === selection.focus.offset
+  )
+}