@portabletext/editor 3.3.2 → 3.3.4

package/src/utils/util.block-offset.test.ts

@@ -1,375 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import {createTestKeyGenerator} from '@portabletext/test'
-import type {PortableTextBlock} from '@sanity/types'
-import {describe, expect, test} from 'vitest'
-import {blockOffsetToSpanSelectionPoint} from './util.block-offset'
-
-const schema = compileSchema(defineSchema({}))
-
-describe(blockOffsetToSpanSelectionPoint.name, () => {
-  describe('simple text block ', () => {
-    const keyGenerator = createTestKeyGenerator()
-    const b0 = keyGenerator()
-    const s0 = keyGenerator()
-    const s1 = keyGenerator()
-    const s2 = keyGenerator()
-    const value = [
-      {
-        _key: b0,
-        _type: 'block',
-        children: [
-          {_key: s0, _type: 'span', text: 'b'},
-          {_key: s1, _type: 'span', text: 'a'},
-          {_key: s2, _type: 'span', text: 'r'},
-        ],
-      },
-    ]
-
-    describe('end of block', () => {
-      test('direction forward', () => {
-        expect(
-          blockOffsetToSpanSelectionPoint({
-            context: {
-              schema,
-              value,
-            },
-            blockOffset: {
-              path: [{_key: b0}],
-              offset: 3,
-            },
-            direction: 'forward',
-          }),
-        ).toEqual({
-          path: [{_key: b0}, 'children', {_key: s2}],
-          offset: 1,
-        })
-      })
-
-      test('direction backward', () => {
-        expect(
-          blockOffsetToSpanSelectionPoint({
-            context: {
-              schema,
-              value,
-            },
-            blockOffset: {
-              path: [{_key: b0}],
-              offset: 3,
-            },
-            direction: 'backward',
-          }),
-        ).toEqual({
-          path: [{_key: b0}, 'children', {_key: s2}],
-          offset: 1,
-        })
-      })
-    })
-
-    describe('start of block', () => {
-      test('direction forward', () => {
-        expect(
-          blockOffsetToSpanSelectionPoint({
-            context: {
-              schema,
-              value,
-            },
-            blockOffset: {
-              path: [{_key: b0}],
-              offset: 0,
-            },
-            direction: 'forward',
-          }),
-        ).toEqual({
-          path: [{_key: b0}, 'children', {_key: s0}],
-          offset: 0,
-        })
-      })
-
-      test('direction backward', () => {
-        expect(
-          blockOffsetToSpanSelectionPoint({
-            context: {
-              schema,
-              value,
-            },
-            blockOffset: {
-              path: [{_key: b0}],
-              offset: 0,
-            },
-            direction: 'backward',
-          }),
-        ).toEqual({
-          path: [{_key: b0}, 'children', {_key: s0}],
-          offset: 0,
-        })
-      })
-    })
-  })
-
-  describe('leading and trailing inline object', () => {
-    const keyGenerator = createTestKeyGenerator()
-    const blockKey = keyGenerator()
-    const leadingSpanKey = keyGenerator()
-    const leadingInlineObjectKey = keyGenerator()
-    const fooKey = keyGenerator()
-    const trailingInlineObjectKey = keyGenerator()
-    const trailingSpanKey = keyGenerator()
-    const value = [
-      {
-        _key: blockKey,
-        _type: 'block',
-        children: [
-          {_key: leadingSpanKey, _type: 'span', text: ''},
-          {_key: leadingInlineObjectKey, _type: 'stock-ticker'},
-          {_key: fooKey, _type: 'span', text: 'foo'},
-          {_key: trailingInlineObjectKey, _type: 'stock-ticker'},
-          {_key: trailingSpanKey, _type: 'span', text: ''},
-        ],
-      },
-    ]
-
-    describe('start of block', () => {
-      test('direction forward', () => {
-        expect(
-          blockOffsetToSpanSelectionPoint({
-            context: {
-              schema,
-              value,
-            },
-            blockOffset: {
-              path: [{_key: blockKey}],
-              offset: 0,
-            },
-            direction: 'forward',
-          }),
-        ).toEqual({
-          path: [{_key: blockKey}, 'children', {_key: leadingSpanKey}],
-          offset: 0,
-        })
-      })
-
-      test('direction backward', () => {
-        expect(
-          blockOffsetToSpanSelectionPoint({
-            context: {
-              schema,
-              value,
-            },
-            blockOffset: {
-              path: [{_key: blockKey}],
-              offset: 0,
-            },
-            direction: 'backward',
-          }),
-        ).toEqual({
-          path: [{_key: blockKey}, 'children', {_key: fooKey}],
-          offset: 0,
-        })
-      })
-    })
-
-    describe('offset 1', () => {
-      test('direction forward', () => {
-        expect(
-          blockOffsetToSpanSelectionPoint({
-            context: {
-              schema,
-              value,
-            },
-            blockOffset: {
-              path: [{_key: blockKey}],
-              offset: 1,
-            },
-            direction: 'forward',
-          }),
-        ).toEqual({
-          path: [{_key: blockKey}, 'children', {_key: fooKey}],
-          offset: 1,
-        })
-      })
-
-      test('direction backward', () => {
-        expect(
-          blockOffsetToSpanSelectionPoint({
-            context: {
-              schema,
-              value,
-            },
-            blockOffset: {
-              path: [{_key: blockKey}],
-              offset: 1,
-            },
-            direction: 'backward',
-          }),
-        ).toEqual({
-          path: [{_key: blockKey}, 'children', {_key: fooKey}],
-          offset: 1,
-        })
-      })
-    })
-
-    describe('end of block', () => {
-      test('direction forward', () => {
-        expect(
-          blockOffsetToSpanSelectionPoint({
-            context: {
-              schema,
-              value,
-            },
-            blockOffset: {
-              path: [{_key: blockKey}],
-              offset: 3,
-            },
-            direction: 'forward',
-          }),
-        ).toEqual({
-          path: [{_key: blockKey}, 'children', {_key: fooKey}],
-          offset: 3,
-        })
-      })
-
-      test('direction backward', () => {
-        expect(
-          blockOffsetToSpanSelectionPoint({
-            context: {
-              schema,
-              value,
-            },
-            blockOffset: {
-              path: [{_key: blockKey}],
-              offset: 3,
-            },
-            direction: 'backward',
-          }),
-        ).toEqual({
-          path: [{_key: blockKey}, 'children', {_key: trailingSpanKey}],
-          offset: 0,
-        })
-      })
-    })
-  })
-
-  test('only inline objects', () => {
-    const keyGenerator = createTestKeyGenerator()
-    const b0 = keyGenerator()
-    const b0s0 = keyGenerator()
-    const b0s1 = keyGenerator()
-    const b0s2 = keyGenerator()
-    const value = [
-      {
-        _key: b0,
-        _type: 'block',
-        children: [
-          {
-            _key: b0s0,
-            _type: 'stock-ticker',
-          },
-          {
-            _key: b0s1,
-            _type: 'stock-ticker',
-          },
-          {
-            _key: b0s2,
-            _type: 'stock-ticker',
-          },
-        ],
-      },
-    ]
-
-    expect(
-      blockOffsetToSpanSelectionPoint({
-        context: {
-          schema,
-          value,
-        },
-        blockOffset: {
-          path: [{_key: b0}],
-          offset: 0,
-        },
-        direction: 'forward',
-      }),
-    ).toBeUndefined()
-    expect(
-      blockOffsetToSpanSelectionPoint({
-        context: {
-          schema,
-          value,
-        },
-        blockOffset: {
-          path: [{_key: b0}],
-          offset: 1,
-        },
-        direction: 'forward',
-      }),
-    ).toBeUndefined()
-  })
-
-  test('block object', () => {
-    const keyGenerator = createTestKeyGenerator()
-    const b0 = keyGenerator()
-    const value = [
-      {
-        _key: b0,
-        _type: 'image',
-      },
-    ]
-
-    expect(
-      blockOffsetToSpanSelectionPoint({
-        context: {
-          schema,
-          value,
-        },
-        blockOffset: {
-          path: [{_key: b0}],
-          offset: 0,
-        },
-        direction: 'forward',
-      }),
-    ).toBeUndefined()
-  })
-
-  test('text with formatting', () => {
-    const keyGenerator = createTestKeyGenerator()
-    const b1 = keyGenerator()
-    const b1s0 = keyGenerator()
-    const b1s1 = keyGenerator()
-
-    const value: Array<PortableTextBlock> = [
-      {
-        _key: b1,
-        _type: 'block',
-        children: [
-          {
-            _key: b1s0,
-            _type: 'span',
-            text: 'Hello, ',
-          },
-          {
-            _key: b1s1,
-            _type: 'span',
-            text: 'world!',
-            marks: ['strong'],
-          },
-        ],
-      },
-    ]
-
-    expect(
-      blockOffsetToSpanSelectionPoint({
-        context: {
-          schema,
-          value,
-        },
-        blockOffset: {
-          path: [{_key: b1}],
-          offset: 9,
-        },
-        direction: 'forward',
-      }),
-    ).toEqual({
-      path: [{_key: b1}, 'children', {_key: b1s1}],
-      offset: 2,
-    })
-  })
-})

package/src/utils/util.block-offset.ts

@@ -1,136 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {EditorContext} from '../editor/editor-snapshot'
-import type {BlockOffset} from '../types/block-offset'
-import type {EditorSelectionPoint} from '../types/editor'
-import type {ChildPath} from '../types/paths'
-import {
-  getBlockKeyFromSelectionPoint,
-  getChildKeyFromSelectionPoint,
-} from './util.selection-point'
-
-/**
- * @public
- */
-export function blockOffsetToSpanSelectionPoint({
-  context,
-  blockOffset,
-  direction,
-}: {
-  context: Pick<EditorContext, 'schema' | 'value'>
-  blockOffset: BlockOffset
-  direction: 'forward' | 'backward'
-}) {
-  let offsetLeft = blockOffset.offset
-  let selectionPoint: {path: ChildPath; offset: number} | undefined
-  let skippedInlineObject = false
-
-  for (const block of context.value) {
-    if (block._key !== blockOffset.path[0]._key) {
-      continue
-    }
-
-    if (!isTextBlock(context, block)) {
-      continue
-    }
-
-    for (const child of block.children) {
-      if (direction === 'forward') {
-        if (!isSpan(context, child)) {
-          continue
-        }
-
-        if (offsetLeft <= child.text.length) {
-          selectionPoint = {
-            path: [...blockOffset.path, 'children', {_key: child._key}],
-            offset: offsetLeft,
-          }
-          break
-        }
-
-        offsetLeft -= child.text.length
-
-        continue
-      }
-
-      if (!isSpan(context, child)) {
-        skippedInlineObject = true
-        continue
-      }
-
-      if (offsetLeft === 0 && selectionPoint && !skippedInlineObject) {
-        if (skippedInlineObject) {
-          selectionPoint = {
-            path: [...blockOffset.path, 'children', {_key: child._key}],
-            offset: 0,
-          }
-        }
-        break
-      }
-
-      if (offsetLeft > child.text.length) {
-        offsetLeft -= child.text.length
-        continue
-      }
-
-      if (offsetLeft <= child.text.length) {
-        selectionPoint = {
-          path: [...blockOffset.path, 'children', {_key: child._key}],
-          offset: offsetLeft,
-        }
-
-        offsetLeft -= child.text.length
-
-        if (offsetLeft !== 0) {
-          break
-        }
-      }
-    }
-  }
-
-  return selectionPoint
-}
-
-/**
- * @public
- */
-export function spanSelectionPointToBlockOffset({
-  context,
-  selectionPoint,
-}: {
-  context: Pick<EditorContext, 'schema' | 'value'>
-  selectionPoint: EditorSelectionPoint
-}): BlockOffset | undefined {
-  let offset = 0
-
-  const blockKey = getBlockKeyFromSelectionPoint(selectionPoint)
-  const spanKey = getChildKeyFromSelectionPoint(selectionPoint)
-
-  if (!blockKey || !spanKey) {
-    return undefined
-  }
-
-  for (const block of context.value) {
-    if (block._key !== blockKey) {
-      continue
-    }
-
-    if (!isTextBlock(context, block)) {
-      continue
-    }
-
-    for (const child of block.children) {
-      if (!isSpan(context, child)) {
-        continue
-      }
-
-      if (child._key === spanKey) {
-        return {
-          path: [{_key: block._key}],
-          offset: offset + selectionPoint.offset,
-        }
-      }
-
-      offset += child.text.length
-    }
-  }
-}

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

@@ -1,38 +0,0 @@
-import type {EditorContext} from '../editor/editor-snapshot'
-import type {BlockOffset} from '../types/block-offset'
-import type {EditorSelection} from '../types/editor'
-import {blockOffsetToSelectionPoint} from './util.block-offset-to-selection-point'
-
-/**
- * @public
- */
-export function blockOffsetsToSelection({
-  context,
-  offsets,
-  backward,
-}: {
-  context: Pick<EditorContext, 'schema' | 'value'>
-  offsets: {anchor: BlockOffset; focus: BlockOffset}
-  backward?: boolean
-}): EditorSelection {
-  const anchor = blockOffsetToSelectionPoint({
-    context,
-    blockOffset: offsets.anchor,
-    direction: backward ? 'backward' : 'forward',
-  })
-  const focus = blockOffsetToSelectionPoint({
-    context,
-    blockOffset: offsets.focus,
-    direction: backward ? 'forward' : 'backward',
-  })
-
-  if (!anchor || !focus) {
-    return null
-  }
-
-  return {
-    anchor,
-    focus,
-    backward,
-  }
-}

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

@@ -1,51 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {EditorContext} from '../editor/editor-snapshot'
-import type {BlockOffset} from '../types/block-offset'
-import type {EditorSelectionPoint} from '../types/editor'
-import {
-  getBlockKeyFromSelectionPoint,
-  getChildKeyFromSelectionPoint,
-} from './util.selection-point'
-
-/**
- * @public
- */
-export function childSelectionPointToBlockOffset({
-  context,
-  selectionPoint,
-}: {
-  context: Pick<EditorContext, 'schema' | 'value'>
-  selectionPoint: EditorSelectionPoint
-}): BlockOffset | undefined {
-  let offset = 0
-
-  const blockKey = getBlockKeyFromSelectionPoint(selectionPoint)
-  const childKey = getChildKeyFromSelectionPoint(selectionPoint)
-
-  if (!blockKey || !childKey) {
-    return undefined
-  }
-
-  for (const block of context.value) {
-    if (block._key !== blockKey) {
-      continue
-    }
-
-    if (!isTextBlock(context, block)) {
-      continue
-    }
-
-    for (const child of block.children) {
-      if (child._key === childKey) {
-        return {
-          path: [{_key: block._key}],
-          offset: offset + selectionPoint.offset,
-        }
-      }
-
-      if (isSpan(context, child)) {
-        offset += child.text.length
-      }
-    }
-  }
-}

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

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

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

@@ -1,31 +0,0 @@
-import {isTextBlock} from '@portabletext/schema'
-import type {PortableTextBlock} from '@sanity/types'
-import type {EditorContext} from '../editor/editor-snapshot'
-import type {EditorSelectionPoint} from '../types/editor'
-import type {BlockPath} from '../types/paths'
-
-/**
- * @public
- */
-export function getBlockStartPoint({
-  context,
-  block,
-}: {
-  context: Pick<EditorContext, 'schema'>
-  block: {
-    node: PortableTextBlock
-    path: BlockPath
-  }
-}): EditorSelectionPoint {
-  if (isTextBlock(context, block.node)) {
-    return {
-      path: [...block.path, 'children', {_key: block.node.children[0]._key}],
-      offset: 0,
-    }
-  }
-
-  return {
-    path: block.path,
-    offset: 0,
-  }
-}

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

@@ -1,20 +0,0 @@
-import type {EditorSelection, EditorSelectionPoint} from '../types/editor'
-
-/**
- * @public
- */
-export function getSelectionEndPoint<
-  TEditorSelection extends NonNullable<EditorSelection> | null,
-  TEditorSelectionPoint extends EditorSelectionPoint | null =
-    TEditorSelection extends NonNullable<EditorSelection>
-      ? EditorSelectionPoint
-      : null,
->(selection: TEditorSelection): TEditorSelectionPoint {
-  if (!selection) {
-    return null as TEditorSelectionPoint
-  }
-
-  return (
-    selection.backward ? selection.anchor : selection.focus
-  ) as TEditorSelectionPoint
-}

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

@@ -1,20 +0,0 @@
-import type {EditorSelection, EditorSelectionPoint} from '../types/editor'
-
-/**
- * @public
- */
-export function getSelectionStartPoint<
-  TEditorSelection extends NonNullable<EditorSelection> | null,
-  TEditorSelectionPoint extends EditorSelectionPoint | null =
-    TEditorSelection extends NonNullable<EditorSelection>
-      ? EditorSelectionPoint
-      : null,
->(selection: TEditorSelection): TEditorSelectionPoint {
-  if (!selection) {
-    return null as TEditorSelectionPoint
-  }
-
-  return (
-    selection.backward ? selection.focus : selection.anchor
-  ) as TEditorSelectionPoint
-}