@portabletext/editor 3.3.2 → 3.3.4

package/src/selectors/selector.is-at-the-start-of-block.ts

@@ -1,30 +0,0 @@
-import type {PortableTextBlock} from '@sanity/types'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {BlockPath} from '../types/paths'
-import {getBlockStartPoint} from '../utils/util.get-block-start-point'
-import {isEqualSelectionPoints} from '../utils/util.is-equal-selection-points'
-import {isSelectionCollapsed} from './selector.is-selection-collapsed'
-
-/**
- * @public
- */
-export function isAtTheStartOfBlock(block: {
-  node: PortableTextBlock
-  path: BlockPath
-}): EditorSelector<boolean> {
-  return (snapshot) => {
-    if (!snapshot.context.selection || !isSelectionCollapsed(snapshot)) {
-      return false
-    }
-
-    const blockStartPoint = getBlockStartPoint({
-      context: snapshot.context,
-      block,
-    })
-
-    return isEqualSelectionPoints(
-      snapshot.context.selection.focus,
-      blockStartPoint,
-    )
-  }
-}

package/src/selectors/selector.is-overlapping-selection.test.ts

@@ -1,304 +0,0 @@
-import {describe, expect, test} from 'vitest'
-import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
-import type {EditorSelection} from '../types/editor'
-import {defaultKeyGenerator} from '../utils/key-generator'
-import {isOverlappingSelection} from './selector.is-overlapping-selection'
-
-function snapshot(selection: EditorSelection) {
-  return createTestSnapshot({
-    context: {
-      selection,
-      value: [
-        {_type: 'image', _key: 'k0'},
-        {
-          _type: 'block',
-          _key: 'k1',
-          children: [
-            {_type: 'span', _key: 'k3', text: 'foo'},
-            {_type: 'stock-ticker', _key: 'k4'},
-            {_type: 'span', _key: 'k5', text: 'bar'},
-          ],
-        },
-        {_type: 'image', _key: 'k2'},
-      ],
-    },
-  })
-}
-
-describe(isOverlappingSelection.name, () => {
-  test('null', () => {
-    expect(isOverlappingSelection(null)(snapshot(null))).toBe(false)
-  })
-
-  test('fully selected block object', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k0'}], offset: 0},
-        focus: {path: [{_key: 'k0'}], offset: 0},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k0'}], offset: 0},
-          focus: {path: [{_key: 'k0'}], offset: 0},
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  test('block object inside selection', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k0'}], offset: 0},
-        focus: {path: [{_key: 'k0'}], offset: 0},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k0'}], offset: 0},
-          focus: {path: [{_key: 'k2'}], offset: 0},
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  test('fully selected inline object', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  test('inline object inside selection', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  test('selection right before', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 0},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
-        }),
-      ),
-    ).toBe(false)
-  })
-
-  test('selection overlapping from the start', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 0},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  test('selection right after', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 2},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
-        }),
-      ),
-    ).toBe(false)
-  })
-
-  test('selection overlapping from the end', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 2},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  test('before inline object', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
-        }),
-      ),
-    ).toBe(false)
-  })
-
-  test('after inline object', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 2},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 2},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k4'}], offset: 0},
-        }),
-      ),
-    ).toBe(false)
-  })
-
-  test('partial span selection', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 0},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 2},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  test('expanded selection at the end edge of span', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 0},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 1},
-        }),
-      ),
-    ).toBe(false)
-  })
-
-  test('collapsed selection at the end edge of span', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 0},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  test('expanded selection at the start edge of span', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 3},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k3'}], offset: 3},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
-        }),
-      ),
-    ).toBe(false)
-  })
-
-  test('collapsed selection at the start edge of span', () => {
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
-        focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 3},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
-          focus: {path: [{_key: 'k1'}, 'children', {_key: 'k5'}], offset: 0},
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  test('selecting entire span', () => {
-    const blockKey = defaultKeyGenerator()
-    const fooKey = defaultKeyGenerator()
-    const barKey = defaultKeyGenerator()
-    const bazKey = defaultKeyGenerator()
-
-    expect(
-      isOverlappingSelection({
-        anchor: {
-          path: [{_key: blockKey}, 'children', {_key: barKey}],
-          offset: 0,
-        },
-        focus: {
-          path: [{_key: blockKey}, 'children', {_key: barKey}],
-          offset: 3,
-        },
-      })(
-        createTestSnapshot({
-          context: {
-            value: [
-              {
-                _key: blockKey,
-                _type: 'block',
-                children: [
-                  {_key: fooKey, _type: 'span', text: 'foo'},
-                  {_key: barKey, _type: 'span', text: 'bar', marks: ['strong']},
-                  {_key: bazKey, _type: 'span', text: 'baz'},
-                ],
-              },
-            ],
-            selection: {
-              anchor: {
-                path: [{_key: blockKey}, 'children', {_key: barKey}],
-                offset: 0,
-              },
-              focus: {
-                path: [{_key: blockKey}, 'children', {_key: barKey}],
-                offset: 3,
-              },
-            },
-          },
-        }),
-      ),
-    ).toBe(true)
-  })
-
-  test('unknown block', () => {
-    const unknownBlockKey = defaultKeyGenerator()
-
-    expect(
-      isOverlappingSelection({
-        anchor: {path: [{_key: unknownBlockKey}], offset: 0},
-        focus: {path: [{_key: unknownBlockKey}], offset: 0},
-      })(
-        snapshot({
-          anchor: {path: [{_key: 'k0'}], offset: 0},
-          focus: {path: [{_key: 'k0'}], offset: 0},
-        }),
-      ),
-    ).toBe(false)
-  })
-})

package/src/selectors/selector.is-overlapping-selection.ts

@@ -1,181 +0,0 @@
-import type {EditorSelection} from '../types/editor'
-import {isEqualSelectionPoints} from '../utils/util.is-equal-selection-points'
-import type {EditorSelector} from './../editor/editor-selector'
-import {getSelectionEndPoint} from './selector.get-selection-end-point'
-import {getSelectionStartPoint} from './selector.get-selection-start-point'
-import {isPointAfterSelection} from './selector.is-point-after-selection'
-import {isPointBeforeSelection} from './selector.is-point-before-selection'
-
-/**
- * @public
- */
-export function isOverlappingSelection(
-  selection: EditorSelection,
-): EditorSelector<boolean> {
-  return (snapshot) => {
-    if (!selection || !snapshot.context.selection) {
-      return false
-    }
-
-    const selectionStartPoint = getSelectionStartPoint({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection,
-      },
-    })
-    const selectionEndPoint = getSelectionEndPoint({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection,
-      },
-    })
-
-    const originalSelectionStartPoint = getSelectionStartPoint(snapshot)
-    const originalSelectionEndPoint = getSelectionEndPoint(snapshot)
-
-    if (
-      !selectionStartPoint ||
-      !selectionEndPoint ||
-      !originalSelectionStartPoint ||
-      !originalSelectionEndPoint
-    ) {
-      return false
-    }
-
-    const startPointEqualToOriginalStartPoint = isEqualSelectionPoints(
-      selectionStartPoint,
-      originalSelectionStartPoint,
-    )
-    const endPointEqualToOriginalEndPoint = isEqualSelectionPoints(
-      selectionEndPoint,
-      originalSelectionEndPoint,
-    )
-
-    if (
-      startPointEqualToOriginalStartPoint &&
-      endPointEqualToOriginalEndPoint
-    ) {
-      return true
-    }
-
-    const startPointBeforeSelection =
-      isPointBeforeSelection(selectionStartPoint)(snapshot)
-    const startPointAfterSelection =
-      isPointAfterSelection(selectionStartPoint)(snapshot)
-    const endPointBeforeSelection =
-      isPointBeforeSelection(selectionEndPoint)(snapshot)
-    const endPointAfterSelection =
-      isPointAfterSelection(selectionEndPoint)(snapshot)
-
-    const originalStartPointBeforeStartPoint = isPointBeforeSelection(
-      originalSelectionStartPoint,
-    )({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: {
-          anchor: selectionStartPoint,
-          focus: selectionStartPoint,
-        },
-      },
-    })
-    const originalStartPointAfterStartPoint = isPointAfterSelection(
-      originalSelectionStartPoint,
-    )({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: {
-          anchor: selectionStartPoint,
-          focus: selectionStartPoint,
-        },
-      },
-    })
-
-    const originalEndPointBeforeEndPoint = isPointBeforeSelection(
-      originalSelectionEndPoint,
-    )({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: {
-          anchor: selectionEndPoint,
-          focus: selectionEndPoint,
-        },
-      },
-    })
-    const originalEndPointAfterEndPoint = isPointAfterSelection(
-      originalSelectionEndPoint,
-    )({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: {
-          anchor: selectionEndPoint,
-          focus: selectionEndPoint,
-        },
-      },
-    })
-
-    const startPointEqualToOriginalEndPoint = isEqualSelectionPoints(
-      selectionStartPoint,
-      originalSelectionEndPoint,
-    )
-    const endPointEqualToOriginalStartPoint = isEqualSelectionPoints(
-      selectionEndPoint,
-      originalSelectionStartPoint,
-    )
-
-    // If all checks fail then we can deduce that the selection does not exist
-    // and there doesn't overlap with the snapshot selection
-    if (
-      !endPointEqualToOriginalStartPoint &&
-      !startPointEqualToOriginalEndPoint &&
-      !originalStartPointBeforeStartPoint &&
-      !originalStartPointAfterStartPoint &&
-      !originalEndPointBeforeEndPoint &&
-      !originalEndPointAfterEndPoint
-    ) {
-      return false
-    }
-
-    if (endPointBeforeSelection && !endPointEqualToOriginalStartPoint) {
-      return false
-    }
-
-    if (startPointAfterSelection && !startPointEqualToOriginalEndPoint) {
-      return false
-    }
-
-    if (
-      !originalStartPointBeforeStartPoint &&
-      originalStartPointAfterStartPoint &&
-      !originalEndPointBeforeEndPoint &&
-      originalEndPointAfterEndPoint
-    ) {
-      return !endPointEqualToOriginalStartPoint
-    }
-
-    if (
-      originalStartPointBeforeStartPoint &&
-      !originalStartPointAfterStartPoint &&
-      originalEndPointBeforeEndPoint &&
-      !originalEndPointAfterEndPoint
-    ) {
-      return !startPointEqualToOriginalEndPoint
-    }
-
-    if (
-      !startPointAfterSelection ||
-      !startPointBeforeSelection ||
-      !endPointAfterSelection ||
-      !endPointBeforeSelection
-    ) {
-      return true
-    }
-
-    return false
-  }
-}

package/src/selectors/selector.is-point-after-selection.ts

@@ -1,97 +0,0 @@
-import {isTextBlock} from '@portabletext/schema'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {EditorSelectionPoint} from '../types/editor'
-import {getSelectionEndPoint} from '../utils/util.get-selection-end-point'
-import {
-  getBlockKeyFromSelectionPoint,
-  getChildKeyFromSelectionPoint,
-} from '../utils/util.selection-point'
-
-/**
- * @public
- */
-export function isPointAfterSelection(
-  point: EditorSelectionPoint,
-): EditorSelector<boolean> {
-  return (snapshot) => {
-    if (!snapshot.context.selection) {
-      return false
-    }
-
-    const endPoint = getSelectionEndPoint(snapshot.context.selection)
-    const endBlockKey = getBlockKeyFromSelectionPoint(endPoint)
-    const endChildKey = getChildKeyFromSelectionPoint(endPoint)
-
-    const pointBlockKey = getBlockKeyFromSelectionPoint(point)
-    const pointChildKey = getChildKeyFromSelectionPoint(point)
-
-    if (!pointBlockKey || !endBlockKey) {
-      return false
-    }
-
-    const pointBlockIndex = snapshot.blockIndexMap.get(pointBlockKey)
-    const endBlockIndex = snapshot.blockIndexMap.get(endBlockKey)
-
-    if (pointBlockIndex === undefined || endBlockIndex === undefined) {
-      return false
-    }
-
-    if (pointBlockIndex > endBlockIndex) {
-      // The point block is after the end block.
-      return true
-    }
-
-    if (pointBlockIndex < endBlockIndex) {
-      // The point block is before the end block.
-      return false
-    }
-
-    // The point block is the same as the end block.
-    const pointBlock = snapshot.context.value.at(pointBlockIndex)
-
-    if (!pointBlock) {
-      // The point block is not in the value.
-      return false
-    }
-
-    if (!isTextBlock(snapshot.context, pointBlock)) {
-      // The point block is not a text block.
-      // Since the point block is the same as the end block, the point is not
-      // after the selection.
-      return false
-    }
-
-    let pointChildIndex: number | undefined
-    let endChildIndex: number | undefined
-
-    let childIndex = -1
-
-    // The point block is the same as the end block, so we need to find the
-    // child indices and compare them.
-    for (const child of pointBlock.children) {
-      childIndex++
-
-      if (child._key === pointChildKey && child._key === endChildKey) {
-        return point.offset > endPoint.offset
-      }
-
-      if (child._key === pointChildKey) {
-        pointChildIndex = childIndex
-      }
-
-      if (child._key === endChildKey) {
-        endChildIndex = childIndex
-      }
-
-      if (pointChildIndex !== undefined && endChildIndex !== undefined) {
-        break
-      }
-    }
-
-    if (pointChildIndex === undefined || endChildIndex === undefined) {
-      return false
-    }
-
-    return pointChildIndex > endChildIndex
-  }
-}

package/src/selectors/selector.is-point-before-selection.ts

@@ -1,97 +0,0 @@
-import {isTextBlock} from '@portabletext/schema'
-import type {EditorSelector} from '../editor/editor-selector'
-import type {EditorSelectionPoint} from '../types/editor'
-import {getSelectionStartPoint} from '../utils/util.get-selection-start-point'
-import {
-  getBlockKeyFromSelectionPoint,
-  getChildKeyFromSelectionPoint,
-} from '../utils/util.selection-point'
-
-/**
- * @public
- */
-export function isPointBeforeSelection(
-  point: EditorSelectionPoint,
-): EditorSelector<boolean> {
-  return (snapshot) => {
-    if (!snapshot.context.selection) {
-      return false
-    }
-
-    const startPoint = getSelectionStartPoint(snapshot.context.selection)
-    const startBlockKey = getBlockKeyFromSelectionPoint(startPoint)
-    const startChildKey = getChildKeyFromSelectionPoint(startPoint)
-
-    const pointBlockKey = getBlockKeyFromSelectionPoint(point)
-    const pointChildKey = getChildKeyFromSelectionPoint(point)
-
-    if (!pointBlockKey || !startBlockKey) {
-      return false
-    }
-
-    const startBlockIndex = snapshot.blockIndexMap.get(startBlockKey)
-    const pointBlockIndex = snapshot.blockIndexMap.get(pointBlockKey)
-
-    if (startBlockIndex === undefined || pointBlockIndex === undefined) {
-      return false
-    }
-
-    if (pointBlockIndex < startBlockIndex) {
-      // The point block is before the start block.
-      return true
-    }
-
-    if (pointBlockIndex > startBlockIndex) {
-      // The point block is after the start block.
-      return false
-    }
-
-    // The point block is the same as the start block.
-    const pointBlock = snapshot.context.value.at(pointBlockIndex)
-
-    if (!pointBlock) {
-      // The point block is not in the value.
-      return false
-    }
-
-    if (!isTextBlock(snapshot.context, pointBlock)) {
-      // The point block is not a text block.
-      // Since the point block is the same as the start block, the point is not
-      // before the selection.
-      return false
-    }
-
-    let pointChildIndex: number | undefined
-    let startChildIndex: number | undefined
-
-    let childIndex = -1
-
-    // The point block is the same as the start block, so we need to find the
-    // child indices and compare them.
-    for (const child of pointBlock.children) {
-      childIndex++
-
-      if (child._key === pointChildKey && child._key === startChildKey) {
-        return point.offset < startPoint.offset
-      }
-
-      if (child._key === pointChildKey) {
-        pointChildIndex = childIndex
-      }
-
-      if (child._key === startChildKey) {
-        startChildIndex = childIndex
-      }
-
-      if (pointChildIndex !== undefined && startChildIndex !== undefined) {
-        break
-      }
-    }
-
-    if (pointChildIndex === undefined || startChildIndex === undefined) {
-      return false
-    }
-
-    return pointChildIndex < startChildIndex
-  }
-}