@portabletext/editor 3.3.2 → 3.3.4

package/src/selectors/drag-selection.test.ts

@@ -1,578 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import {createTestKeyGenerator} from '@portabletext/test'
-import {describe, expect, test} from 'vitest'
-import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
-import type {EditorSelection} from '../types/editor'
-import {getDragSelection} from './drag-selection'
-
-describe(getDragSelection.name, () => {
-  const keyGenerator = createTestKeyGenerator()
-  const foo = {
-    _key: keyGenerator(),
-    _type: 'block',
-    children: [
-      {
-        _key: keyGenerator(),
-        _type: 'span',
-        text: 'foo',
-      },
-      {
-        _key: keyGenerator(),
-        _type: 'stock-ticker',
-      },
-      {
-        _key: keyGenerator(),
-        _type: 'span',
-        text: 'bar',
-      },
-    ],
-  }
-  const fooPath = [{_key: foo._key}, 'children', {_key: foo.children[0]._key}]
-  const stockTickerPath = [
-    {_key: foo._key},
-    'children',
-    {_key: foo.children[1]._key},
-  ]
-  const barPath = [{_key: foo._key}, 'children', {_key: foo.children[2]._key}]
-  const baz = {
-    _key: keyGenerator(),
-    _type: 'block',
-    children: [
-      {
-        _key: keyGenerator(),
-        _type: 'span',
-        text: 'baz',
-      },
-    ],
-  }
-  const bazPath = [{_key: baz._key}, 'children', {_key: baz.children[0]._key}]
-  const image = {
-    _key: keyGenerator(),
-    _type: 'image',
-  }
-  const imagePath = [{_key: image._key}]
-
-  function snapshot(selection: EditorSelection) {
-    return createTestSnapshot({
-      context: {
-        keyGenerator,
-        schema: compileSchema(defineSchema({blockObjects: [{name: 'image'}]})),
-        selection,
-        value: [foo, baz, image],
-      },
-    })
-  }
-
-  test('dragging one text block', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: fooPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot(null),
-      }),
-    ).toEqual({
-      anchor: {
-        path: fooPath,
-        offset: 0,
-      },
-      focus: {
-        path: barPath,
-        offset: 3,
-      },
-    })
-  })
-
-  test('dragging one text block with an existing selection', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: fooPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: fooPath,
-            offset: 3,
-          },
-        }),
-      }),
-    )
-  })
-
-  test('dragging one text block with a selection elsewhere', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: fooPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: imagePath,
-            offset: 0,
-          },
-          focus: {
-            path: imagePath,
-            offset: 0,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: fooPath,
-        offset: 0,
-      },
-      focus: {
-        path: barPath,
-        offset: 3,
-      },
-    })
-  })
-
-  test('dragging one block object with a selection elsewhere', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: imagePath,
-            offset: 0,
-          },
-          focus: {
-            path: imagePath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: fooPath,
-            offset: 0,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: imagePath,
-        offset: 0,
-      },
-      focus: {
-        path: imagePath,
-        offset: 0,
-      },
-    })
-  })
-
-  test('dragging one block object with an expanded selection elsewhere', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: imagePath,
-            offset: 0,
-          },
-          focus: {
-            path: imagePath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: fooPath,
-            offset: 1,
-          },
-          focus: {
-            path: fooPath,
-            offset: 2,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: imagePath,
-        offset: 0,
-      },
-      focus: {
-        path: imagePath,
-        offset: 0,
-      },
-    })
-  })
-
-  test('dragging a text block with an expanded selected', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: fooPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: imagePath,
-            offset: 0,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: fooPath,
-        offset: 0,
-      },
-      focus: {
-        path: imagePath,
-        offset: 0,
-      },
-    })
-  })
-
-  test('dragging two text blocks with the top drag handle', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: fooPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: fooPath,
-            offset: 1,
-          },
-          focus: {
-            path: bazPath,
-            offset: 3,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: fooPath,
-        offset: 0,
-      },
-      focus: {
-        path: bazPath,
-        offset: 3,
-      },
-    })
-  })
-
-  test('dragging two text blocks with the bottom drag handle', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: bazPath,
-            offset: 0,
-          },
-          focus: {
-            path: bazPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: fooPath,
-            offset: 1,
-          },
-          focus: {
-            path: bazPath,
-            offset: 3,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: fooPath,
-        offset: 0,
-      },
-      focus: {
-        path: bazPath,
-        offset: 3,
-      },
-    })
-  })
-
-  test('dragging a block object with an expanded selected', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: imagePath,
-            offset: 0,
-          },
-          focus: {
-            path: imagePath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: imagePath,
-            offset: 0,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: fooPath,
-        offset: 0,
-      },
-      focus: {
-        path: imagePath,
-        offset: 0,
-      },
-    })
-  })
-
-  test('dragging inline object', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-          focus: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot(null),
-      }),
-    ).toEqual({
-      anchor: {
-        path: stockTickerPath,
-        offset: 0,
-      },
-      focus: {
-        path: stockTickerPath,
-        offset: 0,
-      },
-    })
-  })
-
-  test('dragging inline object already selected', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-          focus: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-          focus: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: stockTickerPath,
-        offset: 0,
-      },
-      focus: {
-        path: stockTickerPath,
-        offset: 0,
-      },
-    })
-  })
-
-  test('dragging inline object with selection elsewhere', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-          focus: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: fooPath,
-            offset: 0,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: stockTickerPath,
-        offset: 0,
-      },
-      focus: {
-        path: stockTickerPath,
-        offset: 0,
-      },
-    })
-  })
-
-  test('dragging inline object with expanded selection elsewhere', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-          focus: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: fooPath,
-            offset: 3,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: stockTickerPath,
-        offset: 0,
-      },
-      focus: {
-        path: stockTickerPath,
-        offset: 0,
-      },
-    })
-  })
-
-  test('dragging inline object in an expanded selection', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-          focus: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: fooPath,
-            offset: 2,
-          },
-          focus: {
-            path: bazPath,
-            offset: 2,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: stockTickerPath,
-        offset: 0,
-      },
-      focus: {
-        path: stockTickerPath,
-        offset: 0,
-      },
-    })
-  })
-
-  test('dragging text block with inline object selected', () => {
-    expect(
-      getDragSelection({
-        eventSelection: {
-          anchor: {
-            path: fooPath,
-            offset: 0,
-          },
-          focus: {
-            path: fooPath,
-            offset: 0,
-          },
-        },
-        snapshot: snapshot({
-          anchor: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-          focus: {
-            path: stockTickerPath,
-            offset: 0,
-          },
-        }),
-      }),
-    ).toEqual({
-      anchor: {
-        path: fooPath,
-        offset: 0,
-      },
-      focus: {
-        path: barPath,
-        offset: 3,
-      },
-    })
-  })
-})

package/src/selectors/drag-selection.ts

@@ -1,118 +0,0 @@
-import type {EditorSnapshot} from '../editor/editor-snapshot'
-import type {EventPosition} from '../internal-utils/event-position'
-import {getBlockEndPoint} from '../utils/util.get-block-end-point'
-import {getBlockStartPoint} from '../utils/util.get-block-start-point'
-import {getFocusInlineObject} from './selector.get-focus-inline-object'
-import {getFocusSpan} from './selector.get-focus-span'
-import {getFocusTextBlock} from './selector.get-focus-text-block'
-import {getSelectedBlocks} from './selector.get-selected-blocks'
-import {getSelectionEndBlock} from './selector.get-selection-end-block'
-import {getSelectionStartBlock} from './selector.get-selection-start-block'
-import {isOverlappingSelection} from './selector.is-overlapping-selection'
-import {isSelectionCollapsed} from './selector.is-selection-collapsed'
-import {isSelectionExpanded} from './selector.is-selection-expanded'
-
-/**
- * Given the current editor `snapshot` and an `eventSelection` representing
- * where the drag event origins from, this function calculates the selection
- * in the editor that should be dragged.
- */
-export function getDragSelection({
-  eventSelection,
-  snapshot,
-}: {
-  eventSelection: EventPosition['selection']
-  snapshot: EditorSnapshot
-}) {
-  let dragSelection = eventSelection
-
-  const draggedInlineObject = getFocusInlineObject({
-    ...snapshot,
-    context: {
-      ...snapshot.context,
-      selection: eventSelection,
-    },
-  })
-
-  if (draggedInlineObject) {
-    return dragSelection
-  }
-
-  const draggingCollapsedSelection = isSelectionCollapsed({
-    ...snapshot,
-    context: {
-      ...snapshot.context,
-      selection: eventSelection,
-    },
-  })
-  const draggedTextBlock = getFocusTextBlock({
-    ...snapshot,
-    context: {
-      ...snapshot.context,
-      selection: eventSelection,
-    },
-  })
-  const draggedSpan = getFocusSpan({
-    ...snapshot,
-    context: {
-      ...snapshot.context,
-      selection: eventSelection,
-    },
-  })
-
-  if (draggingCollapsedSelection && draggedTextBlock && draggedSpan) {
-    // Looks like we are dragging an empty span
-    // Let's drag the entire block instead
-    dragSelection = {
-      anchor: getBlockStartPoint({
-        context: snapshot.context,
-        block: draggedTextBlock,
-      }),
-      focus: getBlockEndPoint({
-        context: snapshot.context,
-        block: draggedTextBlock,
-      }),
-    }
-  }
-
-  const selectedBlocks = getSelectedBlocks(snapshot)
-
-  if (
-    snapshot.context.selection &&
-    isSelectionExpanded(snapshot) &&
-    selectedBlocks.length > 1
-  ) {
-    const selectionStartBlock = getSelectionStartBlock(snapshot)
-    const selectionEndBlock = getSelectionEndBlock(snapshot)
-
-    if (!selectionStartBlock || !selectionEndBlock) {
-      return dragSelection
-    }
-
-    const selectionStartPoint = getBlockStartPoint({
-      context: snapshot.context,
-      block: selectionStartBlock,
-    })
-    const selectionEndPoint = getBlockEndPoint({
-      context: snapshot.context,
-      block: selectionEndBlock,
-    })
-
-    const eventSelectionInsideBlocks = isOverlappingSelection(eventSelection)({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: {anchor: selectionStartPoint, focus: selectionEndPoint},
-      },
-    })
-
-    if (eventSelectionInsideBlocks) {
-      dragSelection = {
-        anchor: selectionStartPoint,
-        focus: selectionEndPoint,
-      }
-    }
-  }
-
-  return dragSelection
-}