@portabletext/editor 3.3.2 → 3.3.4

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

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

@@ -1,121 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {EditorContext} from '../editor/editor-snapshot'
-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(
-  context: Pick<EditorContext, 'schema' | 'value'>,
-  text: string,
-): EditorSelection {
-  let anchor: EditorSelectionPoint | undefined
-  let focus: EditorSelectionPoint | undefined
-
-  for (const block of context.value) {
-    if (isTextBlock(context, block)) {
-      for (const child of block.children) {
-        if (isSpan(context, 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}" in value "${JSON.stringify(context.value)}"`,
-    )
-  }
-
-  return {
-    anchor,
-    focus,
-    backward: false,
-  }
-}
-
-export function getSelectionBeforeText(
-  context: Pick<EditorContext, 'schema' | 'value'>,
-  text: string,
-): EditorSelection {
-  return collapseSelection(getTextSelection(context, text), 'start')
-}
-
-export function getSelectionAfterText(
-  context: Pick<EditorContext, 'schema' | 'value'>,
-  text: string,
-): EditorSelection {
-  return collapseSelection(getTextSelection(context, text), 'end')
-}

package/src/internal-utils/to-slate-range.test.ts

@@ -1,278 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import {createTestKeyGenerator} from '@portabletext/test'
-import {describe, expect, test} from 'vitest'
-import {toSlateRange} from './to-slate-range'
-
-describe(toSlateRange.name, () => {
-  const schema = compileSchema(
-    defineSchema({
-      blockObjects: [{name: 'image'}],
-      inlineObjects: [
-        {name: 'stock-ticker', fields: [{name: 'symbol', type: 'string'}]},
-      ],
-    }),
-  )
-
-  test('Scenario: Ambiguous offset inside text block', () => {
-    const keyGenerator = createTestKeyGenerator()
-    const blockKey = keyGenerator()
-
-    const range = toSlateRange({
-      context: {
-        schema,
-        value: [
-          {
-            _key: blockKey,
-            _type: 'block',
-            children: [
-              {
-                _key: keyGenerator(),
-                _type: 'span',
-                text: 'foo',
-              },
-              {
-                _key: keyGenerator(),
-                _type: 'stock-ticker',
-              },
-              {
-                _key: keyGenerator(),
-                _type: 'span',
-                text: 'bar',
-              },
-            ],
-          },
-        ],
-        selection: {
-          anchor: {
-            path: [{_key: blockKey}],
-            // Could point to either before or after the inline object
-            offset: 3,
-          },
-          focus: {
-            path: [{_key: blockKey}],
-            // Could point to either before or after the inline object
-            offset: 3,
-          },
-        },
-      },
-      blockIndexMap: new Map([[blockKey, 0]]),
-    })
-
-    expect(range).toEqual({
-      anchor: {path: [0, 0], offset: 3},
-      focus: {path: [0, 0], offset: 3},
-    })
-  })
-
-  test('Scenario: Offset right before inline object', () => {
-    const keyGenerator = createTestKeyGenerator()
-    const blockKey = keyGenerator()
-
-    const range = toSlateRange({
-      context: {
-        schema,
-        value: [
-          {
-            _key: blockKey,
-            _type: 'block',
-            children: [
-              {
-                _key: keyGenerator(),
-                _type: 'span',
-                text: "'",
-              },
-              {
-                _key: keyGenerator(),
-                _type: 'stock-ticker',
-              },
-              {
-                _key: keyGenerator(),
-                _type: 'span',
-                text: "foo'",
-              },
-            ],
-          },
-        ],
-        selection: {
-          anchor: {
-            path: [{_key: blockKey}],
-            offset: 0,
-          },
-          focus: {
-            path: [{_key: blockKey}],
-            offset: 1,
-          },
-        },
-      },
-      blockIndexMap: new Map([[blockKey, 0]]),
-    })
-
-    expect(range).toEqual({
-      anchor: {path: [0, 0], offset: 0},
-      focus: {path: [0, 0], offset: 1},
-    })
-  })
-
-  test("Scenario: Block object offset that doesn't exist", () => {
-    const keyGenerator = createTestKeyGenerator()
-    const blockObjectKey = keyGenerator()
-
-    const range = toSlateRange({
-      context: {
-        schema,
-        value: [
-          {
-            _key: blockObjectKey,
-            _type: 'image',
-          },
-        ],
-        selection: {
-          anchor: {
-            path: [{_key: blockObjectKey}],
-            offset: 3,
-          },
-          focus: {
-            path: [{_key: blockObjectKey}],
-            offset: 3,
-          },
-        },
-      },
-      blockIndexMap: new Map([[blockObjectKey, 0]]),
-    })
-
-    expect(range).toEqual({
-      anchor: {path: [0, 0], offset: 0},
-      focus: {path: [0, 0], offset: 0},
-    })
-  })
-
-  test("Scenario: Child that doesn't exist", () => {
-    const keyGenerator = createTestKeyGenerator()
-
-    const blockKey = keyGenerator()
-    const removedChildKey = keyGenerator()
-
-    const range = toSlateRange({
-      context: {
-        schema,
-        value: [
-          {
-            _key: blockKey,
-            _type: 'block',
-            children: [
-              {
-                _key: keyGenerator(),
-                _type: 'span',
-                text: 'foobar',
-              },
-            ],
-          },
-        ],
-        selection: {
-          anchor: {
-            path: [{_key: blockKey}, 'children', {_key: removedChildKey}],
-            offset: 3,
-          },
-          focus: {
-            path: [{_key: blockKey}, 'children', {_key: removedChildKey}],
-            offset: 3,
-          },
-        },
-      },
-      blockIndexMap: new Map([[blockKey, 0]]),
-    })
-
-    expect(range).toEqual({
-      anchor: {path: [0, 0], offset: 0},
-      focus: {path: [0, 0], offset: 0},
-    })
-  })
-
-  test("Scenario: Span offset that doesn't exist", () => {
-    const keyGenerator = createTestKeyGenerator()
-    const blockKey = keyGenerator()
-    const spanKey = keyGenerator()
-
-    const range = toSlateRange({
-      context: {
-        schema,
-        value: [
-          {
-            _key: blockKey,
-            _type: 'block',
-            children: [
-              {
-                _key: spanKey,
-                _type: 'span',
-                text: 'foo',
-              },
-            ],
-          },
-        ],
-        selection: {
-          anchor: {
-            path: [{_key: blockKey}, 'children', {_key: spanKey}],
-            offset: 4,
-          },
-          focus: {
-            path: [{_key: blockKey}, 'children', {_key: spanKey}],
-            offset: 4,
-          },
-        },
-      },
-      blockIndexMap: new Map([[blockKey, 0]]),
-    })
-
-    expect(range).toEqual({
-      anchor: {path: [0, 0], offset: 3},
-      focus: {path: [0, 0], offset: 3},
-    })
-  })
-
-  test("Scenario: Inline object offset that doesn't exist", () => {
-    const keyGenerator = createTestKeyGenerator()
-    const blockKey = keyGenerator()
-    const inlineObjectKey = keyGenerator()
-
-    const range = toSlateRange({
-      context: {
-        schema,
-        value: [
-          {
-            _key: blockKey,
-            _type: 'block',
-            children: [
-              {_key: keyGenerator(), _type: 'span', text: 'foo'},
-              {
-                _key: inlineObjectKey,
-                _type: 'stock-ticker',
-                symbol: 'AAPL',
-              },
-              {
-                _key: keyGenerator(),
-                _type: 'span',
-                text: 'bar',
-              },
-            ],
-          },
-        ],
-        selection: {
-          anchor: {
-            path: [{_key: blockKey}, 'children', {_key: inlineObjectKey}],
-            offset: 3,
-          },
-          focus: {
-            path: [{_key: blockKey}, 'children', {_key: inlineObjectKey}],
-            offset: 3,
-          },
-        },
-      },
-      blockIndexMap: new Map([[blockKey, 0]]),
-    })
-
-    expect(range).toEqual({
-      anchor: {path: [0, 1, 0], offset: 0},
-      focus: {path: [0, 1, 0], offset: 0},
-    })
-  })
-})