@portabletext/editor 3.3.2 → 3.3.4

package/src/selectors/selector.get-selected-spans.test.ts

@@ -1,347 +0,0 @@
-import type {PortableTextBlock} from '@sanity/types'
-import {describe, expect, test} from 'vitest'
-import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
-import type {EditorSelection} from '../types/editor'
-import {getSelectedSpans} from './selector.get-selected-spans'
-
-const fooBar = {
-  _type: 'block',
-  _key: 'b1',
-  children: [
-    {
-      _type: 'span',
-      _key: 's1',
-      text: 'foo',
-      marks: ['strong'],
-    },
-    {
-      _type: 'span',
-      _key: 's2',
-      text: 'bar',
-    },
-  ],
-}
-const image = {
-  _type: 'image',
-  _key: 'b2',
-}
-const baz = {
-  _type: 'block',
-  _key: 'b3',
-  children: [
-    {
-      _type: 'span',
-      _key: 's3',
-      text: 'baz',
-    },
-  ],
-}
-
-describe(getSelectedSpans.name, () => {
-  function snapshot(
-    value: Array<PortableTextBlock>,
-    selection: EditorSelection,
-  ) {
-    return createTestSnapshot({
-      context: {
-        value,
-        selection,
-      },
-    })
-  }
-
-  test('selecting a single span', () => {
-    expect(
-      getSelectedSpans(
-        snapshot([fooBar, image, baz], {
-          anchor: {
-            path: [{_key: 'b1'}, 'children', {_key: 's1'}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: 'b1'}, 'children', {_key: 's1'}],
-            offset: 3,
-          },
-        }),
-      ),
-    ).toEqual([
-      {
-        node: {_type: 'span', _key: 's1', text: 'foo', marks: ['strong']},
-        path: [{_key: 'b1'}, 'children', {_key: 's1'}],
-      },
-    ])
-  })
-
-  test('selecting from start-span to start-span', () => {
-    expect(
-      getSelectedSpans(
-        snapshot([fooBar], {
-          anchor: {
-            path: [{_key: 'b1'}, 'children', {_key: 's1'}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: 'b1'}, 'children', {_key: 's2'}],
-            offset: 0,
-          },
-        }),
-      ),
-    ).toEqual([
-      {
-        node: {_type: 'span', _key: 's1', text: 'foo', marks: ['strong']},
-        path: [{_key: 'b1'}, 'children', {_key: 's1'}],
-      },
-    ])
-  })
-
-  test('selection from mid-span to mid-span', () => {
-    expect(
-      getSelectedSpans(
-        snapshot([fooBar], {
-          anchor: {
-            path: [{_key: 'b1'}, 'children', {_key: 's1'}],
-            offset: 2,
-          },
-          focus: {
-            path: [{_key: 'b1'}, 'children', {_key: 's2'}],
-            offset: 3,
-          },
-        }),
-      ),
-    ).toEqual([
-      {
-        node: {_type: 'span', _key: 's1', text: 'foo', marks: ['strong']},
-        path: [{_key: 'b1'}, 'children', {_key: 's1'}],
-      },
-      {
-        node: {_type: 'span', _key: 's2', text: 'bar'},
-        path: [{_key: 'b1'}, 'children', {_key: 's2'}],
-      },
-    ])
-  })
-
-  test('selecting from end-span to end-span', () => {
-    expect(
-      getSelectedSpans(
-        snapshot([fooBar], {
-          anchor: {
-            path: [{_key: 'b1'}, 'children', {_key: 's1'}],
-            offset: 3,
-          },
-          focus: {
-            path: [{_key: 'b1'}, 'children', {_key: 's2'}],
-            offset: 3,
-          },
-        }),
-      ),
-    ).toEqual([
-      {
-        node: {_type: 'span', _key: 's2', text: 'bar'},
-        path: [{_key: 'b1'}, 'children', {_key: 's2'}],
-      },
-    ])
-  })
-
-  test('selecting from start-span to start-span across blocks', () => {
-    expect(
-      getSelectedSpans(
-        snapshot([fooBar, baz], {
-          anchor: {
-            path: [{_key: 'b1'}, 'children', {_key: 's2'}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: 'b3'}, 'children', {_key: 's3'}],
-            offset: 0,
-          },
-        }),
-      ),
-    ).toEqual([
-      {
-        node: {_type: 'span', _key: 's2', text: 'bar'},
-        path: [{_key: 'b1'}, 'children', {_key: 's2'}],
-      },
-    ])
-  })
-
-  test('selecting from mid-span to mid-span across blocks', () => {
-    expect(
-      getSelectedSpans(
-        snapshot([fooBar, image, baz], {
-          anchor: {
-            path: [{_key: 'b1'}, 'children', {_key: 's1'}],
-            offset: 2,
-          },
-          focus: {
-            path: [{_key: 'b3'}, 'children', {_key: 's3'}],
-            offset: 2,
-          },
-        }),
-      ),
-    ).toEqual([
-      {
-        node: {_type: 'span', _key: 's1', text: 'foo', marks: ['strong']},
-        path: [{_key: 'b1'}, 'children', {_key: 's1'}],
-      },
-      {
-        node: {_type: 'span', _key: 's2', text: 'bar'},
-        path: [{_key: 'b1'}, 'children', {_key: 's2'}],
-      },
-      {
-        node: {_type: 'span', _key: 's3', text: 'baz'},
-        path: [{_key: 'b3'}, 'children', {_key: 's3'}],
-      },
-    ])
-  })
-
-  test('selecting from end-span to end-span across blocks', () => {
-    expect(
-      getSelectedSpans(
-        snapshot([fooBar, baz], {
-          anchor: {
-            path: [{_key: 'b1'}, 'children', {_key: 's2'}],
-            offset: 3,
-          },
-          focus: {
-            path: [{_key: 'b3'}, 'children', {_key: 's3'}],
-            offset: 3,
-          },
-        }),
-      ),
-    ).toEqual([
-      {
-        node: {_type: 'span', _key: 's3', text: 'baz'},
-        path: [{_key: 'b3'}, 'children', {_key: 's3'}],
-      },
-    ])
-  })
-
-  test('selecting from block object to empty span', () => {
-    expect(
-      getSelectedSpans(
-        snapshot(
-          [
-            image,
-            baz,
-            {
-              _key: 'b4',
-              _type: 'block',
-              children: [{_key: 's4', _type: 'span', text: ''}],
-            },
-          ],
-          {
-            anchor: {
-              path: [{_key: 'b2'}],
-              offset: 0,
-            },
-            focus: {
-              path: [{_key: 'b4'}, 'children', {_key: 's4'}],
-              offset: 0,
-            },
-          },
-        ),
-      ),
-    ).toEqual([
-      {
-        node: {_key: 's3', _type: 'span', text: 'baz'},
-        path: [{_key: 'b3'}, 'children', {_key: 's3'}],
-      },
-    ])
-  })
-
-  test('selecting broken-up annotation', () => {
-    expect(
-      getSelectedSpans(
-        createTestSnapshot({
-          context: {
-            value: [
-              {
-                _type: 'block',
-                _key: 'b0',
-                children: [
-                  {
-                    _type: 'span',
-                    _key: 'b0-s0',
-                    marks: [],
-                    text: 'foo ',
-                  },
-                  {
-                    _type: 'span',
-                    _key: 'b0-s1',
-                    marks: ['b0-a0'],
-                    text: 'b',
-                  },
-                  {
-                    _type: 'span',
-                    _key: 'e0-k3',
-                    marks: ['b0-a0', 'strong'],
-                    text: 'a',
-                  },
-                  {
-                    _type: 'span',
-                    _key: 'e0-k2',
-                    marks: ['b0-a0'],
-                    text: 'r',
-                  },
-                  {
-                    _type: 'span',
-                    _key: 'b0-s2',
-                    marks: [],
-                    text: ' baz',
-                  },
-                ],
-                markDefs: [
-                  {
-                    _type: 'link',
-                    _key: 'b0-a0',
-                    href: 'https://example.com',
-                  },
-                ],
-                style: 'normal',
-              },
-            ],
-            selection: {
-              anchor: {
-                path: [{_key: 'b0'}, 'children', {_key: 'b0-s1'}],
-                offset: 0,
-              },
-              focus: {
-                path: [{_key: 'b0'}, 'children', {_key: 'e0-k2'}],
-                offset: 1,
-              },
-              backward: false,
-            },
-          },
-        }),
-      ),
-    ).toEqual([
-      {
-        node: {
-          _type: 'span',
-          _key: 'b0-s1',
-          marks: ['b0-a0'],
-          text: 'b',
-        },
-        path: [{_key: 'b0'}, 'children', {_key: 'b0-s1'}],
-      },
-      {
-        node: {
-          _type: 'span',
-          _key: 'e0-k3',
-          marks: ['b0-a0', 'strong'],
-          text: 'a',
-        },
-        path: [{_key: 'b0'}, 'children', {_key: 'e0-k3'}],
-      },
-      {
-        node: {
-          _type: 'span',
-          _key: 'e0-k2',
-          marks: ['b0-a0'],
-          text: 'r',
-        },
-        path: [{_key: 'b0'}, 'children', {_key: 'e0-k2'}],
-      },
-    ])
-  })
-})

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

@@ -1,155 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {PortableTextSpan} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {ChildPath} from '../types/paths'
-import {
-  getBlockKeyFromSelectionPoint,
-  getChildKeyFromSelectionPoint,
-} from '../utils/util.selection-point'
-import {getSelectionEndPoint} from './selector.get-selection-end-point'
-import {getSelectionStartPoint} from './selector.get-selection-start-point'
-
-/**
- * @public
- */
-export const getSelectedSpans: EditorSelector<
-  Array<{
-    node: PortableTextSpan
-    path: ChildPath
-  }>
-> = (snapshot) => {
-  if (!snapshot.context.selection) {
-    return []
-  }
-
-  const selectedSpans: Array<{
-    node: PortableTextSpan
-    path: ChildPath
-  }> = []
-
-  const startPoint = getSelectionStartPoint(snapshot)
-  const endPoint = getSelectionEndPoint(snapshot)
-
-  if (!startPoint || !endPoint) {
-    return selectedSpans
-  }
-
-  const startBlockKey = getBlockKeyFromSelectionPoint(startPoint)
-  const endBlockKey = getBlockKeyFromSelectionPoint(endPoint)
-  const startSpanKey = getChildKeyFromSelectionPoint(startPoint)
-  const endSpanKey = getChildKeyFromSelectionPoint(endPoint)
-
-  if (!startBlockKey || !endBlockKey) {
-    return selectedSpans
-  }
-
-  const startBlockIndex = snapshot.blockIndexMap.get(startBlockKey)
-  const endBlockIndex = snapshot.blockIndexMap.get(endBlockKey)
-
-  if (startBlockIndex === undefined || endBlockIndex === undefined) {
-    return selectedSpans
-  }
-
-  const slicedValue = snapshot.context.value.slice(
-    startBlockIndex,
-    endBlockIndex + 1,
-  )
-
-  let startBlockFound = false
-
-  for (const block of slicedValue) {
-    if (block._key === startBlockKey) {
-      startBlockFound = true
-    }
-
-    if (!isTextBlock(snapshot.context, block)) {
-      continue
-    }
-
-    if (block._key === startBlockKey) {
-      for (const child of block.children) {
-        if (!isSpan(snapshot.context, child)) {
-          continue
-        }
-
-        if (startSpanKey && child._key === startSpanKey) {
-          if (startPoint.offset < child.text.length) {
-            selectedSpans.push({
-              node: child,
-              path: [{_key: block._key}, 'children', {_key: child._key}],
-            })
-          }
-
-          if (startSpanKey === endSpanKey) {
-            break
-          }
-
-          continue
-        }
-
-        if (endSpanKey && child._key === endSpanKey) {
-          if (endPoint.offset > 0) {
-            selectedSpans.push({
-              node: child,
-              path: [{_key: block._key}, 'children', {_key: child._key}],
-            })
-          }
-          break
-        }
-
-        if (selectedSpans.length > 0) {
-          selectedSpans.push({
-            node: child,
-            path: [{_key: block._key}, 'children', {_key: child._key}],
-          })
-        }
-      }
-
-      if (startBlockKey === endBlockKey) {
-        break
-      }
-
-      continue
-    }
-
-    if (block._key === endBlockKey) {
-      for (const child of block.children) {
-        if (!isSpan(snapshot.context, child)) {
-          continue
-        }
-
-        if (endSpanKey && child._key === endSpanKey) {
-          if (endPoint.offset > 0) {
-            selectedSpans.push({
-              node: child,
-              path: [{_key: block._key}, 'children', {_key: child._key}],
-            })
-          }
-          break
-        }
-
-        selectedSpans.push({
-          node: child,
-          path: [{_key: block._key}, 'children', {_key: child._key}],
-        })
-      }
-
-      break
-    }
-
-    if (startBlockFound) {
-      for (const child of block.children) {
-        if (!isSpan(snapshot.context, child)) {
-          continue
-        }
-
-        selectedSpans.push({
-          node: child,
-          path: [{_key: block._key}, 'children', {_key: child._key}],
-        })
-      }
-    }
-  }
-
-  return selectedSpans
-}

package/src/selectors/selector.get-selected-text-blocks.ts

@@ -1,73 +0,0 @@
-import {isTextBlock} from '@portabletext/schema'
-import type {PortableTextTextBlock} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {BlockPath} from '../types/paths'
-import {getSelectionEndPoint} from '../utils/util.get-selection-end-point'
-import {getSelectionStartPoint} from '../utils/util.get-selection-start-point'
-import {getBlockKeyFromSelectionPoint} from '../utils/util.selection-point'
-
-/**
- * @public
- */
-export const getSelectedTextBlocks: EditorSelector<
-  Array<{node: PortableTextTextBlock; path: BlockPath}>
-> = (snapshot) => {
-  if (!snapshot.context.selection) {
-    return []
-  }
-
-  const selectedTextBlocks: Array<{
-    node: PortableTextTextBlock
-    path: BlockPath
-  }> = []
-
-  const startPoint = getSelectionStartPoint(snapshot.context.selection)
-  const endPoint = getSelectionEndPoint(snapshot.context.selection)
-  const startBlockKey = getBlockKeyFromSelectionPoint(startPoint)
-  const endBlockKey = getBlockKeyFromSelectionPoint(endPoint)
-
-  if (!startBlockKey || !endBlockKey) {
-    return selectedTextBlocks
-  }
-
-  const startBlockIndex = snapshot.blockIndexMap.get(startBlockKey)
-  const endBlockIndex = snapshot.blockIndexMap.get(endBlockKey)
-
-  if (startBlockIndex === undefined || endBlockIndex === undefined) {
-    return selectedTextBlocks
-  }
-
-  const slicedValue = snapshot.context.value.slice(
-    startBlockIndex,
-    endBlockIndex + 1,
-  )
-
-  for (const block of slicedValue) {
-    if (block._key === startBlockKey) {
-      if (isTextBlock(snapshot.context, block)) {
-        selectedTextBlocks.push({node: block, path: [{_key: block._key}]})
-      }
-
-      if (startBlockKey === endBlockKey) {
-        break
-      }
-      continue
-    }
-
-    if (block._key === endBlockKey) {
-      if (isTextBlock(snapshot.context, block)) {
-        selectedTextBlocks.push({node: block, path: [{_key: block._key}]})
-      }
-
-      break
-    }
-
-    if (selectedTextBlocks.length > 0) {
-      if (isTextBlock(snapshot.context, block)) {
-        selectedTextBlocks.push({node: block, path: [{_key: block._key}]})
-      }
-    }
-  }
-
-  return selectedTextBlocks
-}